From 92f761777c6e8fc0747db752f46cf30c5ad2cf58 Mon Sep 17 00:00:00 2001 From: zephyrj Date: Thu, 23 May 2024 12:51:50 +0100 Subject: [PATCH 1/4] Update to stable 0.10 of libssh and 1.21.2 or krb5 --- ci/docker/manylinux/Dockerfile.2014_x86_64 | 23 +- ci/docker/manylinux/Dockerfile.aarch64 | 23 +- ci/docker/manylinux/Dockerfile.aarch64_2_24 | 23 +- ci/docker/manylinux/Dockerfile.aarch64_2_28 | 24 +- .../Dockerfile.manylinux_2_24_x86_64 | 23 +- .../Dockerfile.manylinux_2_28_x86_64 | 24 +- ci/docker/manylinux/krb5-1.21.1.tar.xz | 3 - ci/docker/manylinux/libssh-0.10.5.tar.xz | 3 - ci/docker/manylinux/libssh-0.10.5.tar.xz.asc | 16 - .../libssh-mirror-stable-0.10.tar.gz | Bin 0 -> 806420 bytes libssh/.arcconfig | 4 - libssh/.editorconfig | 18 - libssh/CHANGELOG | 7 + libssh/CMakeLists.txt | 4 +- libssh/INSTALL | 1 + libssh/doc/mainpage.dox | 10 +- libssh/include/libssh/config_parser.h | 11 +- libssh/include/libssh/kex.h | 1 + libssh/include/libssh/libcrypto.h | 5 - libssh/include/libssh/libgcrypt.h | 1 - libssh/include/libssh/libmbedcrypto.h | 1 - libssh/include/libssh/misc.h | 3 + libssh/include/libssh/packet.h | 1 + libssh/include/libssh/session.h | 6 + libssh/include/libssh/wrapper.h | 38 +- libssh/src/ABI/current | 2 +- libssh/src/ABI/libssh-4.9.6.symbols | 427 ++++++++++++++++++ libssh/src/CMakeLists.txt | 1 + libssh/src/channels.c | 12 +- libssh/src/config.c | 4 +- libssh/src/config_parser.c | 30 +- libssh/src/connect.c | 2 +- libssh/src/curve25519.c | 19 +- libssh/src/dh-gex.c | 7 +- libssh/src/dh.c | 17 +- libssh/src/ecdh.c | 8 +- libssh/src/ecdh_crypto.c | 12 +- libssh/src/ecdh_gcrypt.c | 10 +- libssh/src/ecdh_mbedcrypto.c | 11 +- libssh/src/kdf.c | 126 ++++-- libssh/src/kex.c | 88 +++- libssh/src/libcrypto.c | 54 --- libssh/src/libgcrypt.c | 53 --- libssh/src/libmbedcrypto.c | 74 --- libssh/src/md_crypto.c | 161 +++++-- libssh/src/md_gcrypt.c | 107 ++++- libssh/src/md_mbedcrypto.c | 165 +++++-- libssh/src/misc.c | 116 ++++- libssh/src/options.c | 34 +- libssh/src/packet.c | 58 +++ libssh/src/packet_cb.c | 12 + libssh/src/poll.c | 17 +- libssh/src/server.c | 13 +- libssh/src/session.c | 76 +++- libssh/tests/CMakeLists.txt | 25 +- libssh/tests/client/torture_proxycommand.c | 53 +++ libssh/tests/client/torture_rekey.c | 55 ++- libssh/tests/client/torture_session.c | 35 ++ libssh/tests/pkd/CMakeLists.txt | 4 +- libssh/tests/pkd/pkd_daemon.c | 3 +- libssh/tests/pkd/pkd_daemon.h | 6 + libssh/tests/pkd/pkd_hello.c | 105 ++++- libssh/tests/unittests/torture_config.c | 105 +++-- libssh/tests/unittests/torture_misc.c | 119 +++++ libssh/tests/unittests/torture_options.c | 16 + 65 files changed, 1875 insertions(+), 640 deletions(-) delete mode 100644 ci/docker/manylinux/krb5-1.21.1.tar.xz delete mode 100644 ci/docker/manylinux/libssh-0.10.5.tar.xz delete mode 100644 ci/docker/manylinux/libssh-0.10.5.tar.xz.asc create mode 100644 ci/docker/manylinux/libssh-mirror-stable-0.10.tar.gz delete mode 100644 libssh/.arcconfig delete mode 100644 libssh/.editorconfig create mode 100644 libssh/src/ABI/libssh-4.9.6.symbols diff --git a/ci/docker/manylinux/Dockerfile.2014_x86_64 b/ci/docker/manylinux/Dockerfile.2014_x86_64 index f41d79b4..226f679f 100644 --- a/ci/docker/manylinux/Dockerfile.2014_x86_64 +++ b/ci/docker/manylinux/Dockerfile.2014_x86_64 @@ -1,35 +1,40 @@ FROM quay.io/pypa/manylinux2014_x86_64 -ENV OPENSSL openssl-3.1.1 -ENV LIBSSH 0.10.5 -ENV KRB 1.21.1 +ENV OPENSSL openssl-3.3.0 +ENV LIBSSH_BRANCH stable-0.10 +ENV KRB_MAJOR_MINOR 1.21 +ENV KRB_PATCH 2 ENV SYSTEM_LIBSSH 1 ENV CFLAGS "-g0 -s" RUN yum install -y zlib-devel cmake3 perl-core -ADD libssh-${LIBSSH}.tar.xz libssh.tar.xz +# Use a branch of 0.10 because no released version includes all fixes as of 23/05/2024. +# See https://gitlab.com/libssh/libssh-mirror/-/issues/227 +COPY libssh-mirror-${LIBSSH_BRANCH}.tar.gz . ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz -ADD krb5-${KRB}.tar.xz krb5-${KRB}.tar.xz +ADD https://kerberos.org/dist/krb5/${KRB_MAJOR_MINOR}/krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz -RUN tar -xzf ${OPENSSL}.tar.gz # Openssl +RUN tar -xzf ${OPENSSL}.tar.gz RUN cd ${OPENSSL} && \ ./config --prefix=/usr --openssldir=/usr/openssl threads shared && \ make -j6 && make install_sw # Kerberos -RUN cd krb5-${KRB}.tar.xz/krb5-${KRB}/src && \ +RUN tar -xzf krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz +RUN cd krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}/src && \ ./configure && \ make -j6 && \ make install # Libssh +RUN tar -xzf libssh-mirror-${LIBSSH_BRANCH}.tar.gz RUN mkdir -p build_libssh && cd build_libssh && \ - cmake3 ../libssh.tar.xz/libssh-${LIBSSH} -DCMAKE_BUILD_TYPE=Release \ + cmake3 ../libssh-mirror-${LIBSSH_BRANCH} -DCMAKE_BUILD_TYPE=Release \ -DWITH_GSSAPI=ON -DWITH_EXAMPLES=OFF && \ make -j6 install/strip -RUN rm -rf ${OPENSSL}* libssh build_libssh krb5-${KRB}.tar.xz +RUN rm -rf ${OPENSSL}* libssh-mirror-${LIBSSH_BRANCH}* build_libssh krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}* VOLUME /var/cache diff --git a/ci/docker/manylinux/Dockerfile.aarch64 b/ci/docker/manylinux/Dockerfile.aarch64 index 5aaf0ce6..ce5d76d7 100644 --- a/ci/docker/manylinux/Dockerfile.aarch64 +++ b/ci/docker/manylinux/Dockerfile.aarch64 @@ -1,35 +1,40 @@ FROM quay.io/pypa/manylinux2014_aarch64 -ENV OPENSSL openssl-3.1.1 -ENV LIBSSH 0.10.5 -ENV KRB 1.21.1 +ENV OPENSSL openssl-3.3.0 +ENV LIBSSH_BRANCH stable-0.10 +ENV KRB_MAJOR_MINOR 1.21 +ENV KRB_PATCH 2 ENV SYSTEM_LIBSSH 1 ENV CFLAGS "-g0 -s" RUN yum install epel-release -y && yum install zlib-devel cmake3 perl-core -y -ADD libssh-${LIBSSH}.tar.xz libssh.tar.xz +# Use a branch of 0.10 because no released version includes all fixes as of 23/05/2024. +# See https://gitlab.com/libssh/libssh-mirror/-/issues/227 +COPY libssh-mirror-${LIBSSH_BRANCH}.tar.gz . ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz -ADD krb5-${KRB}.tar.xz krb5-${KRB}.tar.xz +ADD https://kerberos.org/dist/krb5/${KRB_MAJOR_MINOR}/krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz -RUN tar -xzf ${OPENSSL}.tar.gz # Openssl +RUN tar -xzf ${OPENSSL}.tar.gz RUN cd ${OPENSSL} && \ ./config --prefix=/usr --openssldir=/usr/openssl threads shared && \ make -j6 && make install_sw # Kerberos -RUN cd krb5-${KRB}.tar.xz/krb5-${KRB}/src && \ +RUN tar -xzf krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz +RUN cd krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}/src && \ ./configure && \ make -j6 && \ make install # Libssh +RUN tar -xzf libssh-mirror-${LIBSSH_BRANCH}.tar.gz RUN mkdir -p build_libssh && cd build_libssh && \ - cmake3 ../libssh.tar.xz/libssh-${LIBSSH} -DCMAKE_BUILD_TYPE=Release \ + cmake3 ../libssh-mirror-${LIBSSH_BRANCH} -DCMAKE_BUILD_TYPE=Release \ -DWITH_GSSAPI=ON -DWITH_EXAMPLES=OFF && \ make -j6 install/strip -RUN rm -rf ${OPENSSL}* libssh build_libssh krb5-${KRB}.tar.xz +RUN rm -rf ${OPENSSL}* libssh-mirror-${LIBSSH_BRANCH}* build_libssh krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}* VOLUME /var/cache diff --git a/ci/docker/manylinux/Dockerfile.aarch64_2_24 b/ci/docker/manylinux/Dockerfile.aarch64_2_24 index 3f8c20d5..01eb3ed8 100644 --- a/ci/docker/manylinux/Dockerfile.aarch64_2_24 +++ b/ci/docker/manylinux/Dockerfile.aarch64_2_24 @@ -1,36 +1,41 @@ FROM quay.io/pypa/manylinux_2_24_aarch64 -ENV OPENSSL openssl-3.1.1 -ENV LIBSSH 0.10.5 -ENV KRB 1.21.1 +ENV OPENSSL openssl-3.3.0 +ENV LIBSSH_BRANCH stable-0.10 +ENV KRB_MAJOR_MINOR 1.21 +ENV KRB_PATCH 2 ENV SYSTEM_LIBSSH 1 ENV CFLAGS "-g0 -s" ENV OPENSSL_ROOT_DIR /usr/lib RUN apt-get update -y && apt-get install zlib1g-dev cmake perl-core -y -ADD libssh-${LIBSSH}.tar.xz libssh.tar.xz +# Use a branch of 0.10 because no released version includes all fixes as of 23/05/2024. +# See https://gitlab.com/libssh/libssh-mirror/-/issues/227 +COPY libssh-mirror-${LIBSSH_BRANCH}.tar.gz . ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz -ADD krb5-${KRB}.tar.xz krb5-${KRB}.tar.xz +ADD https://kerberos.org/dist/krb5/${KRB_MAJOR_MINOR}/krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz -RUN tar -xzf ${OPENSSL}.tar.gz # Openssl +RUN tar -xzf ${OPENSSL}.tar.gz RUN cd ${OPENSSL} && \ ./config --prefix=/usr --openssldir=/usr/openssl threads shared && \ make -j6 && make install_sw # Kerberos -RUN cd krb5-${KRB}.tar.xz/krb5-${KRB}/src && \ +RUN tar -xzf krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz +RUN cd krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}/src && \ ./configure && \ make -j6 && \ make install # Libssh +RUN tar -xzf libssh-mirror-${LIBSSH_BRANCH}.tar.gz RUN mkdir -p build_libssh && cd build_libssh && \ - cmake ../libssh.tar.xz/libssh-${LIBSSH} -DCMAKE_BUILD_TYPE=Release \ + cmake ../libssh-mirror-${LIBSSH_BRANCH} -DCMAKE_BUILD_TYPE=Release \ -DWITH_GSSAPI=ON -DWITH_EXAMPLES=OFF && \ make -j6 install/strip -RUN rm -rf ${OPENSSL}* libssh build_libssh krb5-${KRB}.tar.xz +RUN rm -rf ${OPENSSL}* libssh-mirror-${LIBSSH_BRANCH}* build_libssh krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}* VOLUME /var/cache diff --git a/ci/docker/manylinux/Dockerfile.aarch64_2_28 b/ci/docker/manylinux/Dockerfile.aarch64_2_28 index 8c3f0205..a190ac3d 100644 --- a/ci/docker/manylinux/Dockerfile.aarch64_2_28 +++ b/ci/docker/manylinux/Dockerfile.aarch64_2_28 @@ -1,36 +1,42 @@ FROM quay.io/pypa/manylinux_2_28_aarch64 -ENV OPENSSL openssl-3.1.1 -ENV LIBSSH 0.10.5 -ENV KRB 1.21.1 +ENV OPENSSL openssl-3.3.0 +ENV LIBSSH_BRANCH stable-0.10 +ENV KRB_MAJOR_MINOR 1.21 +ENV KRB_PATCH 2 ENV SYSTEM_LIBSSH 1 ENV CFLAGS "-g0 -s" ENV OPENSSL_ROOT_DIR /usr/lib RUN yum install zlib-devel cmake3 perl-core -y -ADD libssh-${LIBSSH}.tar.xz libssh.tar.xz +# Use a branch of 0.10 because no released version includes all fixes as of 23/05/2024. +# See https://gitlab.com/libssh/libssh-mirror/-/issues/227 +COPY libssh-mirror-${LIBSSH_BRANCH}.tar.gz . ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz -ADD krb5-${KRB}.tar.xz krb5-${KRB}.tar.xz +ADD https://kerberos.org/dist/krb5/${KRB_MAJOR_MINOR}/krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz + -RUN tar -xzf ${OPENSSL}.tar.gz # Openssl +RUN tar -xzf ${OPENSSL}.tar.gz RUN cd ${OPENSSL} && \ ./config --prefix=/usr --openssldir=/usr/openssl threads shared && \ make -j6 && make install_sw # Kerberos -RUN cd krb5-${KRB}.tar.xz/krb5-${KRB}/src && \ +RUN tar -xzf krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz +RUN cd krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}/src && \ ./configure && \ make -j6 && \ make install # Libssh +RUN tar -xzf libssh-mirror-${LIBSSH_BRANCH}.tar.gz RUN mkdir -p build_libssh && cd build_libssh && \ - cmake ../libssh.tar.xz/libssh-${LIBSSH} -DCMAKE_BUILD_TYPE=Release \ + cmake ../libssh-mirror-${LIBSSH_BRANCH} -DCMAKE_BUILD_TYPE=Release \ -DWITH_GSSAPI=ON -DWITH_EXAMPLES=OFF && \ make -j6 install/strip -RUN rm -rf ${OPENSSL}* libssh build_libssh krb5-${KRB}.tar.xz +RUN rm -rf ${OPENSSL}* libssh-mirror-${LIBSSH_BRANCH}* build_libssh krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}* VOLUME /var/cache diff --git a/ci/docker/manylinux/Dockerfile.manylinux_2_24_x86_64 b/ci/docker/manylinux/Dockerfile.manylinux_2_24_x86_64 index d07a35bf..4c61ad3a 100644 --- a/ci/docker/manylinux/Dockerfile.manylinux_2_24_x86_64 +++ b/ci/docker/manylinux/Dockerfile.manylinux_2_24_x86_64 @@ -1,36 +1,41 @@ FROM quay.io/pypa/manylinux_2_24_x86_64 -ENV OPENSSL openssl-3.1.1 -ENV LIBSSH 0.10.5 -ENV KRB 1.21.1 +ENV OPENSSL openssl-3.3.0 +ENV LIBSSH_BRANCH stable-0.10 +ENV KRB_MAJOR_MINOR 1.21 +ENV KRB_PATCH 2 ENV SYSTEM_LIBSSH 1 ENV CFLAGS "-g0 -s" ENV OPENSSL_ROOT_DIR /usr/lib RUN apt-get update -y && apt-get install zlib1g-dev cmake perl-core -y -ADD libssh-${LIBSSH}.tar.xz libssh.tar.xz +# Use a branch of 0.10 because no released version includes all fixes as of 23/05/2024. +# See https://gitlab.com/libssh/libssh-mirror/-/issues/227 +COPY libssh-mirror-${LIBSSH_BRANCH}.tar.gz . ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz -ADD krb5-${KRB}.tar.xz krb5-${KRB}.tar.xz +ADD https://kerberos.org/dist/krb5/${KRB_MAJOR_MINOR}/krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz -RUN tar -xzf ${OPENSSL}.tar.gz # Openssl +RUN tar -xzf ${OPENSSL}.tar.gz RUN cd ${OPENSSL} && \ ./config --prefix=/usr --openssldir=/usr/openssl threads shared && \ make -j6 && make install_sw # Kerberos -RUN cd krb5-${KRB}.tar.xz/krb5-${KRB}/src && \ +RUN tar -xzf krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz +RUN cd krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}/src && \ ./configure && \ make -j6 && \ make install # Libssh +RUN tar -xzf libssh-mirror-${LIBSSH_BRANCH}.tar.gz RUN mkdir -p build_libssh && cd build_libssh && \ - cmake ../libssh.tar.xz/libssh-${LIBSSH} -DCMAKE_BUILD_TYPE=Release \ + cmake ../libssh-mirror-${LIBSSH_BRANCH} -DCMAKE_BUILD_TYPE=Release \ -DWITH_GSSAPI=ON -DWITH_EXAMPLES=OFF && \ make -j6 install/strip -RUN rm -rf ${OPENSSL}* libssh build_libssh krb5-${KRB}.tar.xz +RUN rm -rf ${OPENSSL}* libssh-mirror-${LIBSSH_BRANCH}* build_libssh krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}* VOLUME /var/cache diff --git a/ci/docker/manylinux/Dockerfile.manylinux_2_28_x86_64 b/ci/docker/manylinux/Dockerfile.manylinux_2_28_x86_64 index 0cf606c8..4a034426 100644 --- a/ci/docker/manylinux/Dockerfile.manylinux_2_28_x86_64 +++ b/ci/docker/manylinux/Dockerfile.manylinux_2_28_x86_64 @@ -1,36 +1,42 @@ FROM quay.io/pypa/manylinux_2_28_x86_64 -ENV OPENSSL openssl-3.1.1 -ENV LIBSSH 0.10.5 -ENV KRB 1.21.1 +ENV OPENSSL openssl-3.3.0 +ENV LIBSSH_BRANCH stable-0.10 +ENV KRB_MAJOR_MINOR 1.21 +ENV KRB_PATCH 2 ENV SYSTEM_LIBSSH 1 ENV CFLAGS "-g0 -s" ENV OPENSSL_ROOT_DIR /usr/lib RUN yum install -y zlib-devel cmake3 perl-core -ADD libssh-${LIBSSH}.tar.xz libssh.tar.xz +# Use a branch of 0.10 because no released version includes all fixes as of 23/05/2024. +# See https://gitlab.com/libssh/libssh-mirror/-/issues/227 +COPY libssh-mirror-${LIBSSH_BRANCH}.tar.gz . ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz -ADD krb5-${KRB}.tar.xz krb5-${KRB}.tar.xz +ADD https://kerberos.org/dist/krb5/${KRB_MAJOR_MINOR}/krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz + -RUN tar -xzf ${OPENSSL}.tar.gz # Openssl +RUN tar -xzf ${OPENSSL}.tar.gz RUN cd ${OPENSSL} && \ ./config --prefix=/usr --openssldir=/usr/openssl threads shared && \ make -j6 && make install_sw # Kerberos -RUN cd krb5-${KRB}.tar.xz/krb5-${KRB}/src && \ +RUN tar -xzf krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}.tar.gz +RUN cd krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}/src && \ ./configure && \ make -j6 && \ make install # Libssh +RUN tar -xzf libssh-mirror-${LIBSSH_BRANCH}.tar.gz RUN mkdir -p build_libssh && cd build_libssh && \ - cmake ../libssh.tar.xz/libssh-${LIBSSH} -DCMAKE_BUILD_TYPE=Release \ + cmake ../libssh-mirror-${LIBSSH_BRANCH} -DCMAKE_BUILD_TYPE=Release \ -DWITH_GSSAPI=ON -DWITH_EXAMPLES=OFF && \ make -j6 install/strip -RUN rm -rf ${OPENSSL}* libssh build_libssh krb5-${KRB}.tar.xz +RUN rm -rf ${OPENSSL}* libssh-mirror-${LIBSSH_BRANCH}* build_libssh krb5-${KRB_MAJOR_MINOR}.${KRB_PATCH}* VOLUME /var/cache diff --git a/ci/docker/manylinux/krb5-1.21.1.tar.xz b/ci/docker/manylinux/krb5-1.21.1.tar.xz deleted file mode 100644 index d87bc6a9..00000000 --- a/ci/docker/manylinux/krb5-1.21.1.tar.xz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:39183f9e6beceaa5dacf17f90da04fd994236ff5ba9117380048d84af0e862e5 -size 6194020 diff --git a/ci/docker/manylinux/libssh-0.10.5.tar.xz b/ci/docker/manylinux/libssh-0.10.5.tar.xz deleted file mode 100644 index 57e2de13..00000000 --- a/ci/docker/manylinux/libssh-0.10.5.tar.xz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:b60e2ff7f367b9eee2b5634d3a63303ddfede0e6a18dfca88c44a8770e7e4234 -size 557776 diff --git a/ci/docker/manylinux/libssh-0.10.5.tar.xz.asc b/ci/docker/manylinux/libssh-0.10.5.tar.xz.asc deleted file mode 100644 index 01c56857..00000000 --- a/ci/docker/manylinux/libssh-0.10.5.tar.xz.asc +++ /dev/null @@ -1,16 +0,0 @@ ------BEGIN PGP SIGNATURE----- - -iQIzBAABCgAdFiEEjf9T4Y8qvI2PPJIjfuD8TcwBTj0FAmRTm30ACgkQfuD8TcwB -Tj0TBQ/+MS5qNXgV8I/3s0k6jpzTsEMdozOZ7RYiJg9i9UzCGsIuJ0aiMl+G1aFH -UJOkLlHgGXTSCeZk4aoSTky2jEOezcFgsi0v9j8nmxRTjlDDAY0KxOoA//wc5nQ0 -fgQKUbX0SrtIbe9qpffoGBjaEap2ICAiM7a5PJ+Js0RQ944TqmkWmhGP/2XhxsF9 -0TJ6e4ilSg/mTBV5GemLTRSc+MgFoh5jJiV1+zmkOw5bBvPx7/KgsdmhoZ63prFI -8LvfChEEx50lyTXC8eLW4uSvO5tMHyAwDNBJcKOccp5yqEr147S1pZL8iNS0C2EF -/vG7zRDa3dv81xJjuPVdO40/GE77omp1IWC3i4ZskaAocGOmHo7KSwJ/7MjtAuJT -QgqeTPHjENRYbB6FvyesHpWzesORFIxQtCMxugVpEPcc3WLIRNLvJGa7rofAGJJf -u5uLyzmBuyAWm5gpPMyLRy2ysAgBi7NVusnAuR4v28r8YYpGrwTG+epJ1fV6MKWV -tlV8aCY51H7WVmDNJlwyJOwEZWzRdi9n3e22hEm79+cj3WKY3uwYwJI4s0CgcsUw -OzEZt97Yy+pSvdOokgNHRz0tGoDXZw55PF4+mcyvXSQfZJ2QCL7q7dJ/7DmibGgY -LtsN5bSfzXgEBqpty/sD5HSSt1/fNICJjfuiTKtjKXMD45wBUkE= -=IAN/ ------END PGP SIGNATURE----- diff --git a/ci/docker/manylinux/libssh-mirror-stable-0.10.tar.gz b/ci/docker/manylinux/libssh-mirror-stable-0.10.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..15e0026741d1cdb8b96f76c0ba7a37882289f480 GIT binary patch literal 806420 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

M<%i3;Df-BoPWsw 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%0DU`6;qWj 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%0DTkQ6OMy+}Go$}OL#c4)-GNCA4(`J^*Har`qJLJk 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

(0re+pj28^{s` zYvKUbqVj4O6?()J+m|!ZV$^YraGFlc^sHx7I6^>4goJr2_D_zZ*4|Ii53R$)*52_? z8Nb2vfkQ1_-SYFEsSA@!sRp~P8H0NcFM@05$z1StBvUS zx6yHeF!g4M8EfxHq&wu_S*ZkNARSgoVCt~o(=|xJB2^xQ9{1wgW)*;`Ik+SNsTJNeni?=RlA`@)+bMJ zQLT60AEAlM5yZ6V7l=npOiF#wRg7K z@_NN+?74CyqyRD6<<8R%+XJ}x@wLN7EmpA?Hq7KBplEoO6|h}^+5Yjkv$OYR-&5>s z+3oWGRx71iuJU}d()`vQ5UkL2m=>_(8PNCbA9wb4jy*HJzGlN5CRZ4*t^&-x_77-^ z;48M?tT=ufR~4R$xLRLdS^u`2k^yC;;QO0%bd zKC4Fi_vYafcePHQK3{n@W1XPt2Df}a%eOWvsNOm`epf&Vu>2rN`&v2!`Fc7|Dzx;b zwX=J2*fv{g27oGM>r9|WCtGOXWCC?JZwZurHA;3t1(cms%wo?K^#%Vk|Aan&w(|Vj zKxaoEI+-gJ_&a;>eP{oBtJsT$8Jz~&Iy(AcyTgY6Kq9vS6nAMu#JB~BZ;y^z2Ri`s z=wN^Es4d6tLnsOp9S*;kD{3w4rUD5-7iPU~PmlM%Z|_AK=xy_e7u8sASr?_dM`vpv zMcLza^kQMwTY!CdxG&b#i)Xh8^jNHb7te`5!U+VNyvNffjed z=$rLRZ{fznM-qY6;Ir8|7z zLX%Jc+AINzQbskPHg3N~v`R?h?q!FwcyzAPVK2KXBS#7Jhn>Cc{U185?f*HERQc^w z2PlRJ4ze*H(CyZ7%f;!ln*xP{aC>jNy=_4M_PGNz$rBMj8TH@^MGPf>m*-~;Me{oe)_lvfV+0`;u^=Gxl*PaEP= zlfqID+5SP8rgSfo?gzZ^MQyQCT8o<%BjKgYQ`DV~$C!^qraD7yU1At!$oHxonbXia z!|;KVvvCf&PHT5}|A+Rr>_nmM4YM$t=hCH#RXiS#spsi1x*`iU>X=paWbgaE{U7$6 ziZTl*W*K0M-}^?&W)-no%n1kPM`;iBkcp*s8+NlnIy@I;>c+?=R-_rmET|N>TI_$M zqZ31*%5EG7{?v$SZwLxrgc(C4n`PS=O(q#nhob#eVbUx$!0KaK`co*JnCTdN0jyE74vyG(wJ96_3a95F=NB{Owdy-DgER{EKZw z9CG?-pU8rE#&)P4|IxAP!McTgrE_%LI&QPzY1YPD5k0`D)xV0b^*VCR9E$6}Fq$j+ zI+*(9Fp>qL*FPVkol2hr36?@UfD1sv(|>Cu5O*ji1VqBKe`_Q-cMM*101}>?{W#*J z9Ap@1cdg~xlVrA1-2x0ke+{%sGiY~mkyCjNF&eDkHt*LHqJ221zFpX<}CO?U6|Zq(`t zYpw-SkDwQGuW%piB4`;qAjAv)Ty%H7=z!fG?{Dwx6CCYjIDL_rJ~BQ#O(JpPwYOVq z0G>&I5Fn^8g>%Tu`7+@LILFsF;T*p=!vMM;Co3{R?2_Hb-(!pab6J1Ed#SMQC_N3} zsc`KxED4v6^@=D1fZg9|?czx0qIIlSXs<#YVrbztRt1bCf*_P?i>_2K2oH2FO@*Kj zI3{hicm5XS4EsZov9O{vZA@``vKCn9_1FBG4?8l3OQ2gs| zkg+%;6DDOd8QEfr#0q@Krr(+DNA!0wdAs7upK&6Xy(Yu*3T0##aL)Sic^*Bo>c81- zy{&YpnX41wvjgi9w%?(TAZ0TpCqeXmAsbntPMD=isK5}m-`%=IzE3i^P;Q~UKygx2 zN=Rzb4Bu4*M>1m>n~=UBQAF5Emfi#?yGhrmuDw-WJyf^7_5T0;?FQ`@O)+13>Y5XN zi+aRc078(iPGM4M%7rKEbOF0+-z+ciz3eE_)b7sNXXi>%5~NEtTK zp{jSWa-Mv=vy)I&Zt#1q)p?g0W6lxhs{$~w{{^jA(~>`QG56HGsAi?+9*BKx6>(da zgsuZXXdOQN+o&zR26t-&Y|zFBf-J&R+&AbbVDq%k0i{8n?Taino!)TS!(qzTV#1 z3&<1IAc$z?`)}T~4{rgExX@Z04EnF^A8y|mkhbn$OmPJ3Vmd^dJPLggW75kIZ?b!$ zJ5sP+BdEgORHlK#BgDLbDb7M`*9MJt_VWS~1PE)UI_KnL-&~yY&QFSea?YD`PGK?~ z;+%_FJN^f7&OZRhn+FR0xwpT!pnXdvh9gKVQ1b>7--@eh|IMymQP-Y}?h7mX4yS!E z$ML>>{BD0++PweCI{(0|)4o+S$o4@Q&nUSUECt~*jfLS9xW=N89JaA27@Kc=ahINs zi+Iq8c`FLITko|iuDa6#5-UisRV``NZw4IF5{R+-<+0gd1!v-7HUX1xRfJ!Gx&xFuRF$5V@ z>0eiod8*^NqR@ooxk$S+C!}KgW*~$``Y}V%P_Y-p9R3K5@OKd_G;(h!4OrJ5U+i9P z1^g(O61?!;7kcA*c)0!D-4|Bi*j(MWo@`K|B^hM0RRKG^=HE+1nPX)l9&WgjXmY;X zB@~Js^OBdr=eVx(#+vag$Xs&D-bhjmj~jy?Nj5MUU8dM0icS+L7_xbfKHPi#!?4qmTfp$`p;DL2qlMMX`O z!v<$*s@%JPLN{G*yh8D%GYU?PbT+fXpSP#;_TUeD^tK~71&`j}e0JBC-&OGVa$Jv` zm{uX>)iZ*wjy)_hCYCUKC4*!DrB~Zk-hpKL4GB+6-0iYffx6o-GW*$?ax zIQw7d=1_6=RbagTfSI%cXBPD^-+qoO(m(lZcz!TSXxTovSTwRf=jXQO#|r1_SwGMJ zoS)x!e)iv#xtV=?qi9%v&d-hKha!fCJ(Iuv95ILPMw0NwLUkm`-|TuMNOCneQ@-Cn zZvRJ+z>H9n6d(EvBmusd$n~`ZDG2@}W^9IPl7er4fiw1}Zs^~G{AQ>oF-*Jq`6vDT zNq^D8^e2*JzBK45I^oFn5-W|Uml5XJ9-zz`KsXTSmd>+D76GpL4fGNIei;l_k2pk- zp0S%4!jImV_J{5NX>Vb|OFN|f%g708kB^$GLSTCXo8AtIL00OK%py=4W4}sw%xL>| zB6^sxLy;yyI(TsASs?E5v^zoPyfa*vWIDjjU^?DtdrIN|KP1j+l=R3)0oMal&n9OXq|_#N?P`M#O<2Qy<>Sn*|AC{Bm{ zs0<9ECDreaF$S5gA>1*6hfT_zv!N+W_GXj6n1m(J$Q2yI)V2urv_D`lrkz)y=*p{U z4rqO348mwzbvIC3bcj4P?GBlk2p}-S6Hjvbc7}-4~kP~G;Vf~yCDDaNCHN?`zOc#hO_D9Zd-o6fBdfEnBAGZ zr9OVLcpXn4y!$WCoff@s{V2FBWyPsCPjvc8?8HtBVUwJpK{Xkfsn zCebtDDr{hPQ)J{? z)>C7`P#vbVa@xvq<_tr3E0D88TC$2{d>Sil#}niAOhNQCs99%fza~|{X{8T0Bqcs$@n_T z2Otec{dAB{EL7KZ4_01@O*b ztH3O;S-T+28GgXtCjEE>0PBxb?LG{;qidIQgixElF~N#04C(OA*0ZP2o&kaI<`X?# zZGsrr%?1Nfxu|in5VrpRJ#9+q2kAXY(eRNQTGo3d%1!ZQmV%^|LH|zsus((`djk$l z1M~U;PdSr|aW*}_pe6ObwG~a`a{)>t)i`F zo(@L+WFk`)TKN;<{CbLK`7?obo(>qOVt}jB-;;3`4U%}6vj8Z9`5537rm^NQIfq^4 zGKntZ{xlI4lkqr16&aq-fwOfc=2=`&r^IBP?%Wm8wO43vk!W%YY~5m5SWB__FkfV+wdiHxLp7*J zJAZE3Z9 z?l5uJ<{}_UU?hBB<&8pJaX8Gw_`XyY{p26w!1?iepr&j#zG%SYDFhdjw!q~20ahB|b9FLeih)8XIxq@f!71Syk z5|I~c2QV3(*X_>9)Ac$Z|JLRjU}0-0Wjgw(@p!Z1R>O@!81jtMr|esAf)Oyp`z%!SYyo8~GnBRyLi{tC8e=odiks&87bGLPRK?w`DU zr@s`XI$7J6>}=NP?e>PRf;uaidV@t)YKUbN*&n=ej?^}!CzS5YfCudFpUF7mFdSDG zSznz@G5odeBazIiOT5mic(CbT7DdsxJ{{r}1WKCO@O;Ujr@&?g9Y05jcRFg2uF#Zx zQAx|9fM;#tGp_`SPmR&=($N~?Kw^@Qm!euZfS>6IM;Y7H(CN1x?ItWYS2yoI1|usi zR|gtcswDs7Q@Voj@e98AIP2Kxqoc`_n?3LKK$;~aPEd?xVo=peIY~R+VHV5^K|{mA zEKe!rquf^V?N57lU?5{)8ltmh*X^agQdp1F=aL>pP$aijj-A`~lHlKI)Vunk79T zg*Ljbx`q265*-(+sTR;;)nNdORSfHB-DmdkQa*l}$dG!X8qOBeW38k~e9DeO@+lsP z!f$>08GJDG6(Pf5GOMWeRc8vJP2v4kYFY9SG-)l$*2{F=`IVz9-eIe59XBd4h08w4 zLtI&kRxV=LU@6(CIP?Mh05JbPYpi_DF<+I>wY!W&(~B=5m!r)O!8xSP55U?K7O1ZF z!4(_S9WJanI$8PPVLmmnFz{;g&X??s*nUXmBOkqAqu{yeQD%iZd}n)xAw-sVe0|Vr6lhXywco1wZUy zM8vJuL0Gjt>c*o^ck;1J5~L+W<+34-@@kx#VzY!%nf}Nb2D*he*qxod%JrOe=TWgQ z2+GvA-XSf$fryZ4#%zhLpl=PH2*~N1rRYr!ecbMB6&g+_-S&6H#z|&nCS2* z&hrk*Cccxq9d>^z-C}x zw*?N83!hQuI-As#A$_RBAwjT|NXo=BR}=k1>u_&p@9hj#^g{h~iPij7pr^-=J*vT( z3c0W|m*cfns9EOC<1ecmG2E`2MWp??>!na)6Ieu!z2M?2;D%E&aW2Dzr#vrd(y-Va zD)v8EJuv2i&fA8_rb4tJui~MQ7)V5p;%Jy$sVkm~w4Vr1ljLL4os!uNh;lACX_qEU zSsi_qvxqC*(`oxG=aNq!jz{r0PdaEEBd5cm@_DXx)O8MtPVBXQanXzTl7>Aco~}o= zhS+*H@oU3>!&Aep%c(?@YrYFz>jd258_tC_%PiVZ*?(>{95#dNw}f@GNh++_6xQsA z*`l;Dx-c!DB|A;#p@^Ge66=msLVL2O1SzWU zO@l1uT?)-S#m<6fAL6Ys>=Qw|m4vBv!@XHG`yOOZuFEoDKo4|}r@ zU)7Nj5~*B_i1;H#lvI~iZ+8t4M8hWt&IFz5Fh$p;K>{0j&qEqYj9-bG)d(YGJX5yE zA`kJHd?{Vbccx`RV1IZ=-eMSEC?g+HZ3sc;L&%EB397^bV{ZH31MVTpB53n#SSz{B zRkH+MQA2jQ2R>}dS+|W9(2z#e@>Fsa`K~7z8c3R5z?+=KFK5YDtjt~lE59PO z52!4~eKF44aF!d#lMEPcDxC!J6wcx0WSBW4A`>>P{F?TO^xl9F)cN6X=eYgD{@(HH zU3gm-0qpp&wbcgn$xvCM4ZeEmT)~*x4o8l-W-{9+%WS0pg8nESk;hvy7)`E$oy&j+ zXW95F9{1R<4SkOpz9oO9Qb_ElIeQ~YJQ%T~L_LH2`J7va+JPgy#M`EY+YUJb*A2v? z`?s^K=&O_!JA8^xsDE`8>`#54>-I(>c>dafsp*_ehZI$#dN=00la^?jvpfn!Xf@rr zN{7Ad%H4)=($fit#?qf;P$gK7?m8SN=YW4yM>*TFFHRD#JeDeQPslR|My_>S>V&Wv z>7Xlaap_Gff3Lh^KgAO1VZ*Hf3}wgyxasI?7myss581U(Z^xUSOlEh99cbY z=;})%jDs86;B=fOXXu-nTh7ora)Fd4<7*860&5*7({i%6+YHU1D6JdNT@!O^-!i+! zJ!giJ!kP&=zDjd9qA)CX;ZBwf0s;{4Ma3l`VNi$S(a5@1aywCZ(r`^)ChoM^7PKYv z#?^0U>H-^|6L`?t9M00}NRSif-yjr79#I)kwL5&Ov>HUHQi)3$)kC2(a+ZN8Uyf4` z&fJb_7G|+73EnL(Sr|o5A0w8V8}iN2UKM;Z?*NkHT8f^?5}sZyDVP+6#9=~RV;80C zLvIV3VfmSdq`Gc7<@eHj6r);6(mtAQI+NtEve?yk8gWucTSEU)V7ybTR7t*tVk#`l zmxZ-SaCi4gU%}EssS}6_&+THtkb*fL?~t-#FCaRXVvS zU6cxqx1_|JrJ)IQ{tanlRGeh1@t4uVJanA~oj!LJ7^a!dC#z$j2*V-4Y(Y)2aW)AH z0q7eV6F~Eth_17eVSL&bcd>L~J50_q;B9yW;JfVH*k9ycfrSB_zM50q2B7T^$#tomAp=0s4@z)8>~SDQV^rb{@7m(Uy`E)@M?vj`4U~I< zX6zwF3m!*FCqwOe$l4LD?KM}3@lt^6qhN}D0VM2BB{Vmw*=i&e;k+7Aob2tqKiF-* zZzFlZn$E8{(prpGG`#D2zI_BiC`e?b7BC$At^cRBqZZdkSgxq zl83-t3L4R|-a|iOmR>vct0Kjt=*~iZNd?hai=MpPugWpcMY2hEGst-kI@19M{gh@1 zsm4~c)!N;C4S$;Aj5Vub!pv#hC{AG=<=!PJ-6PAG4(WzpFbV$7*YEl_2f*{vz;sAd zAbmP(xWU1x=GO{SQrRAhH&+rfxw%rz)s`$ihoe;(Hs+X>LU?-BFDUXJEJ1eqU&{c^;EW%&IBUKR6tW&EP z9#rP=(|7@WbA*UQ8u75D%v`9gS_-^)Vj zsW_4xfRF6W^6w{r)JiiM))|mEWmj5CC2jdN7cmAfq_D0FyAdhVwUai%Dx$P9 zso0GOjwhzih&K@}FI8Cn3`Ddifc(7n3kf9jHf8R2mX7lYT@OpySg=8mk5#@b+st1t zIX!)j|I{sp)C@Rz6iv88P9AtG>m(JZz$0Au4pzkkoI1i2AiL`K%J5l*=@b3ptgX~{ z!|=0lXA+9bA=1fVvGOnScUsH4Ur6gj=_MRc!jPiRj1C^QGva(X7Futd_rvo|&_0eS7Q);~F4Z z69%$d6`vR%Wz~c;J_cbG&Q#_G)3BPgEu2WVS~PE}BB>qjz4bc^hsjlpPi|foX$6pO zV@!!}2Pe=K5oM0IHyBq#K^8qyrM^*xp4r$~3Z1COlq8k#H|NP(KBC3h1qH|B@=K)} zoH}Xtrd>V^$_Jh&5PyKg=jS*cNwZnGWSp<}x0q z*;J$`$XDgp9}+x2qOziw=IGEfP4f$AWO9X`*dV{;30WZKI=9Y6N)}xLkeM_`M#(4~ zpyye36&OafSP^b)cqK6|-B6ea=!>mYSxsSFWEDgy+JX@{tKn}~zTeI7UpF(8mM-LV zs9VsH?o*Nd&2XIad%O|RlzPmC>p7zdsNTGx*QIaR)fhu}(hcI~!)YTT->|8@QLtlJ z#4cd)t>%Ifo?uhg0gO(Y)*E$_wcc71i}l6t3}!olc{fEj0CYhd4qU2u&cXNuwqnk` zhnF67N>aBVbQu|)O~(|XN*oPflh#)0_jS^^8-XU>%o5J}K3(^1|eVR9DGYmx%&`OBVCM35v97S4{K#xiM`#E|9%) zK>%VD(6_x~w)65_N0zE+Jqb}~YYs_6sNHHP6C3^IxdN*m6~fD^&FbGp&B`|$zqhIk zp=b=vc1SAvH%pwlzM^)`C2fsxER(EKAC)%}>_o|G)S^_B=$G8ktlZ2VuJ#bIcyJ3k zT{9LqlxQ}*HG=&@_-40enk9J+n~^|?w;47`W$MMCMUsEb z*jVwjP@1#CPUC9SxeW_&e^)C~i)o@G{nn+Y_As9$u^aSrS)N&e81nQIvnuOMgeFT} z;(Z5*f)AiB7~G=HsTrAOl=8uz$LX-pq+Xh4-Yd3SC@fO|mXAONOx(Z}(R3se6H=Z+ zw61cp12g63Dk&CGl-r#rzDbzrv#6=ZxpFn;%bX3xEJb(((`d@RUM#S=9}>0s7qO## ztR~}YWnqU5i$w#2JKLw*{qI#ogBgNr&@;`yAc7(UN`yzphdW!x9H zZaf`Q%vn1^1m#-`1u2mya($sQ(&C6gzVLNVQi%@xvTY3oJvUT(BUi9N^@u zl1F(W@Bl6klH>#LdBD?qGBY_je2|L=Q^qwQ+CiKRydLhw61r?@-$nV%6n%^ae37uK zOAG;z_M`OtB3fNtrJb8X->8EnFGR|cN0t-OVKPeMNg?e4KBb$RcFnEg09}!t;A49n zW81G!-n?lacHSJe+a^H6YOCk(@qLq zT>esOpFvLE+uuJ>m#R)Wb;WKSm7_ME!2IdLL5fAoemY1e>~15BpfMzRK1#ajS<1Pa zJXz@1&AqLlzeLSN^M#YA6Z5k7<1wsTGfiH7H#&v(mni$@ApV#RrUR53)|Z#-yHB1i zi7QQ$S$I;53j%-ftTS0^M&Ets>C^JM)abY-5~6Q8$_KJ@IrWEdgS}}+Z(m20?z)=| z20))0G3(Et&hDJkyQgbQv(&yAMT!&_6hEFjG8$)>X^--5kPmx9q%2KT-|9jb zN0WS&$(Wo`-JCMsUccYjs~101xqu8c>lt&oP3OVk{_+0Sz7rpzc9cl!<%5!ulwC}p zqbBwyjaN2$`zY}Ms?TA&Dnyu)VlC??4a*r+9ARz8=>ZoKN`bv3PjQD*3QTF<>AK;T zcmo7+t<2Pf37Kl7ljsIL4s8zSQSkwVMAL|t_0@*Q<1OI6#z741DZ;}H>ddtMcJpCg za5&Ll9~Dv^M}LLcgnua2XytmSGscSeFV|f18M2!5IIk(I-;9ckt$*9pUE3(O>X3@h z7$aO@h^C7o{f_vR5c_>x{g%NLB~)_gsb?l;kokj&W{gUcHog6Cz-Sjxs~mIjyu%1TwYAymMC4dydo zL!>^K)tACfRRL+CIz?>EYTcfw;^HmU6d9C^!d*7h1e~LmN0N6W%!;JGn&W2eCWGQNb`7~5Z*mB$m6La1kmbu=8Q!5z?D4FgYICp_8sqDoq$ zi@FXf*2K|-X5oAsk1pWABt0B-2ogpa6*8-%)(0=vk^}`=EXa#VezRcBDGb>QNa>&Hu&hpP{*$y+FX`5$i$rO0H3DD!1LMRo zNe4;cpo5_C1Hc@NsFAw%H|oc^Y!k~E6cap`1kWNEtvKT3FFr5pP=}v1*VfkTGm$lG z$n|vkXy+oLxGf7K5M)Pq&E3=KqG*A^5!T#Y-BlHCRd=Ym=E_f_0w~_?-VUUlzg1f4 z7|CCG+9Dr~a+FvEcglox9MW%l1WY%n=NzoWbP>t5(WN`RG$$ox4LEb?6a8ZnVCR~a za!`M;c`5kw{pHW+-|^|Er?4li3{s@H71$O|`^n1MYIE&LKJGq|;bl%&yEkY9So+$F z7tiQlc$|NmUqAi&>%TOgJ%83*|N2F9eI4GfuRVS7^p`fH0_i9wvue2oObBNXhl*?7kAtk6k<0$9mnHqQFJRCU60fA zi%C@PE=B8W%_cLN))=a`dhsB}*w4LGgSMbx1E@TJL&(|WDjp{r(RDVZ;cIPbqIR8MVkE)eYD@6JcitG`+Qd@YBxTTNuO68E&_Yh%=nv zA+DSZ8X$XiR~ymuZ=>S`qgO-+=S&4(o<3b`M6a`aLTc^h=zS|%TW>a-E6t~C zUpJzYqt+^E$nXD`NE?nBL564P`RYZ@c==sE=>gAPy?78E?ChO0iH@_uhKUpRMG{ajMVNO)=dR7rCvt%)jD)CKVDU0Z< zI#3~sf%2BYbhM`s%PhpP6FkX=hDwywUBDTnuT6&n7Mk%*?C2-=1KA6ouB%`tkFZq| zSG58~Nvfhp!%240ud9M2Hj4I(z;z!*8w$9r;^>g&Aa%vgB*WmvV_8E;(`4*(dck230)ly$psKvSTV0I) zDt^C=YQxO*3Z3alDjF*5(@UpQb9LaT^`>oLnlG1(_!-@PmKWk@aM$HKIG$fBnl?

3iw2%veQXBX=f|uVExP<-Gin9>$H8#qdSL00TH6!LAp@3(8JTyv%sWc-T+@6j znw}0-E-h(ErSXAT&=4O^?vJA1>nA;B=32muoh4=4B`$g>j3}ppquU*9j=sPdR4UEG z^s-s->mhP64Vw^MsFY@?9rBowec+1`6=ntA{4E*7!BL#4^2t|uq!`O89C&_w-^L4g zv_a3Hw<;l#!IT0zS)4QKfP%MS4{la*+twDkdY;Hsd4$LjpLGl;2|Z#VKlM101+^qT zaxL4rMboIRU%U*N6)^!s_70pSv++cafpAop$Z8lp#As*fxpD0wWW7_^JXD2%r00At zyXp)3ma5cp8sTKAEU-JkVAKg2!vU(t3COd^LGrMX89IL^z0M$k^K~!(8T;~X|L7PQ z_b;xY%LBf{geE%Y;|v7O>Y!$5rC~HHuW(oEbc-h5^D&Z&8Qy9Knh;G4)*t3euyzu% zxS_E!GW|&~1uTtes$VKT8$&HER(+Oiefb>z{XqJf<}Zn*%#&sq>Q*YIS5KwVe$#>O zm?GTg7mEYYF%!%c3Ib&7_~fvy7HO3b2e&B1=#bAm1In}j_&RL}a)xRFsUsASR}0oh zidRq*sc@pDkci6M4*h3Hz@SZ*!!9c)fCl*qNOx~mz{w{?S@S4CUwuzE zjKh0LJmKovA~`_CI%cZptUea_t97Rw?1tu(6c1Jh>ei40@nNm$WY$6dxR_%NVW_Wm z=~q#6{hLbtmRSLBp~GR^WSB!bj~-4<;El)~3qfIDKBAN;jlQ!B!K=rQEl&f|;SS?L z61i5b{E2dV6uwcSzro0~>6;O+I>!z_!iL}<0(ygV3JNoA(h4HQkiJ=tGs1ROxa*@h zErhTun+#(@2n&M|YhdAzI(NUuTlfl!dU5~Unr8C9!77_xTMATH0b)_e$9W>%CdUGD zOen%5mSe4M5r4DKciAKpNP}|iHUB3X|HKMnUy76+% zMPn9cFZ#W&-+%X~n*9fgq>Gz?l-qx-ufKTy!nOZsHlMBiY5(yV9=87w6CACe``Fc4 z3KY>j?b6NA&CNd6o}$CvpGF^l8h!j}^f8aohhfKoBV{8FuN{c-F3sFmcwEMJXfHBE zgOSb;J9|&pjWWYzf<_`w(xF{9U_L@tC;JEOy`!Vu&eq{i2gmzHC7{k>p7)<5mm?dR z{DAQ_7qdqxGyAw2VWhFX#*zv##FYS*kXNm85MDLXB;_CuP4My@`?ivedlUmg)srpDY)d1dQ8E(m=qx&h zHHxrnrx0OtIN_>C#a8Gg7#lXOmJM3f%7H(2ed#AFu8 zYQa-wxj98P`I0XN>Y z;d&Sv;lpBR53loG<(t=;x30CVfCs8f>Or<-K%s+af0CkX3X33g?OM~lt}B`Q;XkM0 zyH|&-yoy(U8Z_U=<_!nWfPBU4^SF72f8|6o!`H$lwM^VPs}_a3Kiq9g;H7w3~ioKYQA(_ zW!b*&doo~E&3~l~3+wY_OR_Q)In2F6f}dIJ8mjxba}AkzjH@ihh@!(J3N!1-3>;z3 z`F-Bpc)4^r`bJY17jC#N-4r0)r_8kKa<35Zl7N-wi@5LE1O&e+ZUVkiiVHFe0@ySR zC*YN68R-Si_>IWlQ+%ZGZ9!Wq7!(@u_QkasvZc=6{$AUb`0nf^LFZpawGgVY<4Q_>u<74RibEQWfvnEzwKrIm=r_$#X!yslR><>L z97CaxBC#|!Ui0AH->D6$^w$mG|B{cRe%ehZozs6NF*XKgJ%?dtUrj2M_HBzIf62F7?*rO6CqUhtC*w-`7xCPx-jF*R5dDSz21S2w z2mQwZZ&BljP;xk!5x*4=a2JzoXdK`SRTQ86e4D=?y9H?`B5}rFI3VK$cH=TF?HoNU zVHA4PyHOXk3=*7R+!wtcABjc0SU-ZoMPbWUssh@xyFvtTKD~F-S?+;Uzv3u$kxnB@t5D! z&q@65H|jg{n(tkuLkzRBZkyX(ER6hug_|#+uwZ|kLHxfNmZrk+r(&w5mC~WAgn#-f z$zDa|S^Ljym~0543TnN5e~g&uXIXRji92eJHfyj79?1NSK0W335nE2{dD+&PtKT48IENC z#a@pQG6y*0zuno2);`9~)AjDt-ZT5_-`a=d&HBFeKfun{10Q$x;Nvq5czgG_bJ+Sp zNw3Xy)g!cE-8oRSxpfe6^b%arqBgLtH#>W>?%Kz-rupgUC-c*~`RVZJ*!c9!{DgXU z{plO?Q)}ycU8}ifemXgPt3R!;g_o0IzgB5E00DVc#3YA9b63qD<*t=fBg0?YQw}wz zW)-W(AnlGbZ#Cpo9fRob3SW6Z3etkVWT>0?l0^z)8Wx}ogf|C}NGhV~S3nW8M+Smu zlnwmD(54DJ%B%p%M?ewm+03BW%~)d_&v7Kg4cWCs!Ha#2GJGATBFt{UzRk6ycw?;{x z<>^F*JF-9y_1oD~OBgAiS1NLKk#;X|vdEPP@E%h*pG%V50RKrm$o-Rq)r}c?v$NYK zlb+Gk8aH6a?Y7a|E;KN~U}VGO$_5=}r~eC6$W2=x>>gnH74qMX3cB1vH<$5^%(#sx zu=7(t}aB- z<^+2trj4=!DmA|9HdU(IsKvh;hG((>i17=^JZn5QDUuSE+)K}_@nTK}{7sf4Knt6j zgoXR}?iH0H_W;7CC*!AzGkFhM+&t4gHF7_SG7Y>SXg16im$*|<^}Dq|yChRvUpP>D z5W}#JFxRw!V|99=!HX>lIfa-EbvI?rMqnC*cD&kbG$Lz5KrrF}F&5Uz0~%H*sEqI4eIwJmZKVW# zch{&z(6`nM|0!ECqS(#>oLG^MgVHKx&`T;54#i)G)&Ip6yjhRX`9t<28|L@C970qngqjwS1|<$Ko7!294m zz^(QAi~wRloxesQd)cU6oz|9$&6MsdVdkf}TUmWSA>ASedtQ-)>6$1@Va@fsTYLI^ zdW#FZ`NC`@uNRNGpRF-GHqYG{9v{Sgb^kho_0yvm+CoLKChyg&VR&t!=9OCGGqhzo zT%BT~@_b^PD66-QrVJun$8LLXp{`sdtV3swZw?2g73kQ`!F(MNx{>*Na7XOE$g@S% z?E=%bg>KD?=N7U_hW7JgA3J8znQi3fl%C17#~vML5cLkuhX!%_xu;FX#2bJf6wW1Q z&fRmQ)NlBXlJZ+Y>3}nz-Ju6cbtZ18}Nw z2l~Pq?oERct>)>la~2QMK1Kj;z3H6n9UZiV>CvYkpm8$DC^X=lkT~xDBs%Nq7a(@Y zvpsQ4BhVhnk3fK!YT;+W5%%^e5FRjmW%Q;vtwhSaR!(+AcIxEZFwS~11x2O|&(3;_a?MaPeO@rV`5SLv{af#eL!Ie!j5%Y=$ zF;uA$Jt|ljeRo6e)Wi1wJ3*7f?e^YIdpqc+`WDal!*fBXxTv6G0G$JT1!{>%pWGL^ zEo?}lX+#C8F)ih*W0MKqK_?~yDMcsO`U3DN*6Z(!P#ii&M4tm6`@=qJ z*e{<&`E-QLTIAIwQKz4sp98W2fgy|Ik?|FX^-85YPPQ5&B3rp?Sj8mL92lsY2M9b} zK@eEV3qb4qt#06J8-^|zgj4K_AB^k_Gi-dTE<<3IG&fxPG$FdlYq*_*ciV?3vq$U3 z-P~5-tu9^He?B(KFO}=8#f6eMVZ*kz;7$RX3UzfM8@eCdgPtOc}E69F}Ld3#iPCAdY)kQhjW()&^Id2+yxF0E(<=V-we|4Nk5N+_Yy{;8gAN z**HEQaP%N@$}g+>;#tG2dVIWFUfgbJG|nbjH|yizH(!+ZamljUASag`n1jp;Qw@nFdR--wk zpo20Q=sC$i4eK4ulQ0!w6)q74SFY*m95 zUp#;Q^ts(BtjM~%%5siT)08FVtvel`qol+Ky-B&4Rc9yQB|LOcjin94oRdHpbU#lb zATvm(-^xgdM~w*S(JywQ3PI)dVWp0F!Ih4r@{NUcJncxuyrYZPb_`?;ibr3}JSsBb zk??OG?fJ6R^M&BVBFzjPp=0wr+%g)njZdXLBf=73^Wt%r&#_Rt8|QQfN~3Scqi}{! zMOSH_*aurY&?q$fgRafE{W6Zfn}u^5T}J79p2cp3%)7f!#ru?dX3j@$9q%^o6}l)c zfeJ;@rp$f0N!LlmJ3=CmPaHR!80M2@?K&gv)Q?i~*vTi;Q$b%ULw3%oKZluA{R~E_ z$Z~4O;;!I+B4Sm~c_%BZO$F|Jo}P2wgIWNgb|q`qf8Dq5{65`=HIO|t@kFO%<%vHklx(=x7`1C{ps`P zUq3DQ|E@p%`cMDg&+xGSFU|7}9f6x`AxGe1(dG*L=V{a$_QpvJTW9xTn4~BJei!G% z|K_k6gS7u)H5;G5@YS7{__sqc`8>^a{4+-bFlFg?0SuPhaFeeUbn4 zMOMDZ0k75%sUiz8!tax7X!Q)%7F~l+$4S_^^^J;WiU=nI88kMgo^w8Ec9-JNQp0pK z?ehzCH{<5u6Y(N;M~W!_yf(IBBP`8~q^j5Po-IwJ;z<@#?v&g`AIxHom0>X#i<@`l ztUH|aJ>J!ThT>a_xg>M6m_FW-;d{Nak6zbNq-u&LBVt8t_Km;9%_?1OcH~PgLL#YA zhJHsK^_ojzc0Z#KrHAaumt15zL=RP?5Wk2z>VxeEj(sP8QT3WfIJdlA=G7g{8-u%B z;C&}p3CV9>=kY=YpE zN%!9Gw~m_4&dK3UR2zNh=FR3yXinXC!f=SnI!Ppl4T}ukb|`l?2BQjF$8g72Mo?bdetu=Be8){42sRl;%LQS|=4 z{nPPJ2iVM!R8}|<2cQ9Ug%j$;;q7z+z*x76q2}6KRYq+ooAE#kJ648C(=jh199Uz{ zG1Q%oFG)C~-zcP^H2{W$M`LHM!3v=MwbmRhGZd0mkfR}VV2+r=8n{T%$Z>M<)r8ecvmo;ex;($y!-3gVUEzVq?V&kScpq4viyT(Q2aE$ef6o;>>`ITBL zyS=rAWcg<2$M@~%buvMz65nxh)nStKKz5Q>=)&jJ?pfOFOfv2uyj^*vUQ;A4vzwZw>tpY;-H?m=g_b>zlAq0*_sg!cq2X3WaVSLW$r1!WO3&FwiONOxzuaMsQ^XJWPJ7OzQ`_jLx zl_^v4wYRCXxryuyqkWJ7;VYfM612i#v740YTGB=~gP|DA_a?)aK9zW!>8&DMI@Jl2 zyb8eKl?e|>17~8W&Hz|NH6rU`V}_G79}@uJsAcr*1QnZdCdAwkwU>jh4J*}GsOa=mmsFI}P5feud*z}ETTLl2X0TSd4ar4s=gx%7-Mp(nVYpPzBQ#Om5da(*hAG4GP^_&VGp7IqM}%*<2aARk)Y>n* zHhk}&e)DW*-RJ8~r!JFnp%;R-!vGJ}s_}LPIyn=B?spj^=(76kMEv#)L=-JvjXK0F zrCpj=jG;5s60YyiD#;0d-$bwouCq_3n4uPzXH9Ko!%O707>MW`HZVLy(J1ILS>)R- z9x}KLKB#4j`{%IRO)dtiYL~%!YF@-JP%1`&tl*bh>3&I6_m=3A(#r{?DuFjWlgM8! zoGO>WEm^i5{Dhr(wJAUT}bMIem1Q?$G{A&1ggo4a&@* zCaa3@=tu8burgj+eH2)$jpe}&&uklIAf7kZXMlhbZ4(S8y9$xm;`hH|K@Ez?+&|!1@AkZ!#6Ln!Dlr z6sn7=CO1?o(g+Q&?c9GzjD&a; z6L2L~16#4gzB%>1Jg2q}Um9J?;#K8R)T-)SPJ z(GQgb0T;ASM^)A}5)ozrfg&@2fFLmo2owndVfn&~CO#U4YHDdJFq37AxB`cqgC&$q zQUIuDt`=!P%Xk&$agheJlvrVo=WDD|V^)623Y(U@WfkR0xgC(qLbnr!Vw`sjGFUUt4Ww=N z92|sOKVGkhPK{$S$T*ABe&Dvl5Fe}!nQwf?m|TM5Qt7Q>sVp;uA*)!H_H{B9A zOC+ucQ(x`Ogo;vfMW|4822|g!c57Ys?RFJ`L(w^b<1Tn>XfZd)DnJdI4T7A_BX14y zCA@Ra(eMhyZ@c?%>*C+e53R#JXy%0FO5;dR>;MBQ&|glBk8)-Z>PAtxCPx7yyBpnA zoX070DPi}**R(wfP;|x4;93#x=n?XwI4=bQ_tV_pMzp5Q-Yu(lWY4NbM-=zl{F-drR2G=;1%OUJ#Yo7S+e)MIZa+~+*Y>Zm>-#hGN=NFmbd+}nSud%3QZp92Lg@L(@n)!I zGP%flIZ^Gq{i9>pPLG_Flm*|R3b4iTvJ!abpsJEulHvVP`|xk=L;9fCvCg_vVMV~2s17zSs zMVYfFrh1pqgM~s`F!4s12!XNb323rb%I7FO7-k`t$^0JXe6vQ#`|e@>s>b=J8`kXD zH_S*ogBT9Y9kKwlCO~Dch7M4!d#yVBXCjw(2e$q?GJrukqz?_R7I#SV&=I-hO+fB7 zse}`K7k&NW8(#>6l9i__qu1H9Z;V;>ttF#$b8Y=ukp>Jz)m8UjZK{gCn`)X4X9Gay zNo)s6Frvs@=kd6g%YYwrV}r0q8EgY|5t5IRZhDrIL9w-QSP4ev-4(DQd}Jwk>r&hX zCgW*h?gS?PKZ_BU_8t%|F zW^gI!WuPy@LOMUhaqy}vq^4811*>e@PuU8{I4qiiTyqLEl1<6{0hMlO7a^yRHoOKJ zcEUK>>K5d+DET-62@Geae)wi9`sV4=^`(fd{D;YTHc81kq&FQ4(+a2n`}6QT@u><` znq8zW!T)YqrD$E32zS0!`UL^`gtC2I5 zZ_)mI68ArdoI)5G2*h1BCwZs55jgilFH6`=O}J2L1T8b!pi3l77Vs!GMKX@f$f)ba zVj=-QdWDkxqem8|i>1D!;mGK`JA23VuN%=iS_Lg>qnmPpfHy|(jMjdbg@yXVk4qa- z&0kx49XhiSaFKRLr&HL^o?3jgi1wznyW2T_cesD@_T6kPwcaZOBDrM4?!i4cJ&H-> z(Ia-5`w=?3^OgvXPpyT`xcqp_<6FGLtPEJV!%)3iht+}B=`gISZRYF7DG6CFG=NMQ zXR=(E#B)8D7P-Qez^q|Z)hAcDIGCj#sj6A7aJ?{#nkwm-XWc-Qs~hG~iW-XOa)oI@ zGzc6ewrNMRPw~=~orHcRBs`pYxK~Zs9J6OZuhxiecC|QL5%L!O{I%{ycU+oZTfJA} zvSExOM>JE+$hDYp6Z4F_Gqu2jxi+^@Jy}c;nI(agSY#NdET0*kmK_{r`Rz&%ii7_P z&8}btfAU^M+^InE%@-n2OfmBr6(@5~&OvrFVWO%XgB2S_8zgN8WM;Vm3%=p%5d0QJ ztbNc{CgrwQYz63H6~1o)&OlY@!9_0tR9Wg+Uap-$TeI!hgx8fqg#U^vnteqz+qO-C zsB*z$Sm9QlBOm6v|N^wdG`1ptK`j+5Ocm_N>wc>3qFoD;)-C@z~#fi#!*7)l1HEnHlu2 zyR{q5qGW&D*P2Cve*U}7a=Wq)^0FV$NFhz>kAnO6b+%~Y3GKc^UdV~ zj?i#ymY#9K9)P4JN_U=*vSCjiGEC)bNY)VtU=&=;(wIp>+Z$MQ3vv(EB`FTu_0*~$ z`;7W=It&}`mMG5gsbKqA#l&ris3@bSw;N=*e3jPCN_hg<=*_N00a57r0srDq zbz|iwD(AeHQBXIuDe}SdO(snljj+KJ>zzK744ipu7Bz8BiS=R$bEgBCu+QPhtR>Vm zvwi@!!W3bP5?on$7(dvAs{FU>AMUw8PzC@Zq6}^74?IRk#TIE|3>w>df1qj4HqUwB zSqmSUmi`GJZ?WJ7V&Ov6hm9&O?j>cJ$rr4RCgUNJh2d3>x_r`YA~eUbyhsb)itF=L z#1z|}I!lERLpMa3&&z)VS{ z3)L)QV}&Bu@SC8RF-dlJUccQs{ORD>qPO$z__~uPA4i>W(obRxkBs0kwgHdR38bN* zxM9!@7fEk_$hu+S{)~ z@jOS~dCsww52w`+o%5U}OAJNABPsdrc-R#tP+!BfMbM-Eb%arm96F7@{ z8D!(@sJp@)@>qYIzIaB`H*2;;x#%M6vvv%V)HD2K*v)zj-2-M6=lSSjjOae5T#f1{ zhD=K+X0<$asAzH?IPr9H(K&-NM{7ubM`t2(E*(@b>4ZG2Omk&9;lama!C8AYYH>`qEs+jj$ zF;W#NRH=#Gp{eTvc26-yk)Vhwl{p=yn)#~j;p{Ds4C{HrpkA1((MW_YyCV|vs0goE z0;NZ}l#KJ}Xm+?Af7W0RtOs%iDg$zluRD8h_HCrpj>p$R3l57E)^{X>>FH_PEaXi# zR`*|{8d~1hqL)#PTp4PnFCd!Pp|zK^-yzOKd`hT41j{U7Rs@NaBp2}x{4NwG)~WA_ z^hUT;#4gKAYG>kiz*M$lcabt@#W@Jvt;Jc5c*oggw@wtYoiXD%a@wS1;MqB8>yxWNt^_M= zm^6wsZqt0*tyrbJ+1hQxDI@bn$|~Qar~D6e*4(Svq|^y)1`ln!xJip}u`D(Wl6aU? z<{$++xHo?}o4gW%T4wTS+Q^-KzBr+CZuBCFvEJxad_`Drq|sXPXdJ&ra1AuWLYs;>Ismqq$jo zw6ZEB>O6vgs8p(EG|YNLw?i8p&v$)}DK(#kx3~rOxY?VW7_Pg2O|lN~-+6~Q|M2D< zR(QMOam=}2F)gBA9pgP4D;}F5kV_3$`Au&Fr%?K)g(?C+?-r`$R_tA97j;guJMtuJ zZe-#BOL<|?_mVO=ME})nf)sO^cD?(G%%djm*TfHT-(>=42ZSKoR!w2Lh=RF@18nY% z);tZHaH6Ax_B?Si4iOPuxeYn;J%^Qt(eUl6;XUz%Z@HdxbzsXCe3bTCxt|8HqxM+@ z?>kL9n`<82S@++_yK$mG^ufTJJ_?IYMnB1TkSecm_4JZqieBBu?p*CKUVa*WZZp@0QJ%U;Sh4t4h4mj1Hnx z)98CBNd|dmI!@~0j)3oYRtWRyE|5t7WO@ ze5r^MvHb0eRmAlfk|Ga0qkmv`eUzI!W-%@L8K*g=(i@B6;yjs9A_iIru$O&SoJdPT zs^s2}llHN_x8L47e(Cwp+S+O#y)1Obhh_uSZV|6goS&}d6A?j#l0G4UBcWs7rv<3) zU~FY$I8D#bDSKf&jGnz;H4Qub6I$9~!LE$kaozjJQPa*{9$46_Gp6FqxU`OCxH645>QYh>RZCebSSIU>Zi>?doa9}3N~vF#L&0qu{TV}R17@j+mS zi8w#}sYUy;M0)%1C9nd;#Z{Rp*vqNBk(R4ehh@mhb8E2v2*R>Av$$V>Wl6{*TOPi1 z<<;59CoEps!s5uc*HskLWpQ`ccyqG1b-c5`chs0)oV*+H@lQS8f4Uw|ib|s*!K^qQ zPIT0uyvOsX^hi!q;Ad#|pbe1EnslUPN{5=Wy34t1^;xu>7jge9U>y;sJ(P>(j=plm(nskDV-3ay_IV;ef6vh)TeZaAF(>5d68J-jh5q7}?3^ z=E=+(^esq(HFwzhgCzLbhnFM(PLDdAhW2ejcaH9vp%&{)b9NEMXZQCPhY$v0P?47)S-9E&F^~a}c{OsyR(14LK zLao5h4T*I6WnJM=jj>&0Y}FVWHFORM7e0`OBy$H7S9is06%4oSRF8s8ASd z8%!}s<|=3L3_3SJ3C1cjE=ozDoVpDD>>)2(nh28E2P@-Qki_gw(@Z>ddt@ZrAX0)K zvK>WBs>IkSL9}C#i7ZE?Vw58kS0)QN{c>&q7bvv(PLFh(yil$wIU(Xgn*XU%q0Csy zT5Oh}sm*UbaGKbLw~s6&1`7RJrOO8G_jS0(o?vqI^HGOWVflPZOJRSKoQ4k~S7bMAAC?KZUC4B>wX{I6Gi zyTL)ojp`4))nE*D+F1YvfPr2k;(_7Lv*<1}^l-mnk(UoEG1SBZEGYs@Dgo4Iwh$W&{}MZ(=~!!e)P82yUwlfp*h;%+^0CsEmj(;r zfqIzs7TXJPBTU6c2tD~DY-%u8v8&OI2l*<)J0t$5u{=~nh}6d%3(Gbzerj?vT4{y` zUxjV?8Vr>y!1GRx7hrGc1BXwel@RPWU|G6$;@KyaD`z%bBx?T9#I*!mmHg$(J}Wy<{{_*q62RQ2%>HFEmGa zb9Qn!>Pw}){3Gz0{{+3|ZE)U#it!G$i?^*2ycwG*yaG0HGU{1pVh;-sA{HSVmw&_}fO9gx zn=!u1GB!SQGCK`G|Mj1B(@_0(V6HofFY1OsGt|)-h^d?PqldjO_KE-#g5BtX;3n4t z!OH>B3+&v6dMWtHWH9RF{MPg*mQGqG+|v7nC(GQ!WtA9>T{!_y<4Labkt?w_&M~L6 z?nwi%G@-2M5|E5Q4JA*LWJqxyqKqS27$Fp4($iitoTO*hRtu{V&Jj#b|2m3$J&cYO zpU3GCTj#j5Nk17F;k&!p=vs!m9w+%k0%6&PhGlVG=OTp*6gg^vH1WTcuSsZ*M7ctk zNQPp25n}0zop6ubfF*Mq!2vb61EL9cpEJMd6ZqOf4U3h-jaoZcRmcu4w$3P^m_Zc{ z%x#o7w1;ujy2)zvKU1KHSky^#QIrD2F+7@IGwl~AW)~5^;q-%X5(*@06OlQa7547= zr!+J}yqIsC5l|lCy|RmB#}ix_N^W``LCf zf&E2BipQ9j6af=6vkgX^@7&BK;Mv)*oQjtzlMB#x^u#ce5A7V37(tYKBKA~ogEHJb z=IX-ks$iYeM~w1K8e8PEq_eG!K6LYD^JUFynG$^25$&JcKh3hf-Y+;{xheX>2vv$* zlOr?d5=o)E=$5Xr+`tdWhx99l6Ky&wK{16mKAS)Cd+NC%posZPWXRcrBJQMMB4eVO z-!xWEuc3)iKkg#xYDiX_Vm@j(o#G8aCxJp#JKo>ke~IGIIJ*>qQBjLHE)obrL!5g1 zQJ7yNnS!PyyNa1efg}!VioMc@(mtz1LKSiiF?BEvNb-=OTBoNJwVwE?9H2!s@};C4 z@mAEsaDlejs`Ewkh-Zdlm*VFt*D3ZK&QXKsc&QM>P4x@OuRO|rC@o4sSiZ%qC>r+7 zlcFeCH%s|pz?m=WM|H9J%SrrECU1w+e)whSa(Q@WLX8GM6GhX1CY=e&xzJuCN{csz zzw)bU**6-v%^3~;N2cH)*QTOa|2t>ks2n0$wtt6Vl0Qe54LhsGWOi1K+Zy+0&7|Qg zQ8AIm$^XyZyZ^Ou9gV~NwfQSH^b-O^V1zG8P3#tfZ1ar`6mZjg)4Y0D(gItgU0Ev` z(>Cwl{?5#~-}WK|CaL#%8l&BFoik_7+|JAkUmlImX)o?N?M3Z07c`^=Z_KLH7D!~b zg(?KPW}LiK9MJ6Ovz`PvORg#t0rwgE#-#$e7{2tsQbzFR2G+eZSbSxJVhHn&pz<=l zIy-ndE%z){$ueSJYaxA7$vP_+bFR#^`8^J_r8>N*nL`g6wte*c%dD2#DucEz_ED}U zx=0{@ln)2MJ|*kJG&A@}zOH;l@h0t<8PZhJE<}eFyehJ}9i>3c85Y6c-+ZG3jp-_i zG4k*$K&@BDKc~N}+F-?(22P5{vPk|~U%m5w4kbNeOp)4z{rU@C%jsKnB2_DNhV$0%t~RFqNR+%t>xsRitWe zE2mfP;ZrX~S~)Zmck7$1JSbUivtmFJMl0nT`Ppi9r&#K>S;|51v)w z6@v0S{Qz8*VCyQiI=c2)Ywu=i7`>tYQ9TT;V^b|mDSA+2rjEde9j}rs!Q3aPoyQKw zaXRr}fjqgQQ+{l5*PK2a@YBSjO%^xxq9gg2z#FWBmoHc=PlL;hIWnH|i%z;n5D>6l zIxRrN-8kQf+M8RCTG7_#qwiYLqs>1*Sq-)~Xx!ez&2P6>Z=he)lP(Ly4i4|`Dcn^& zAzh6AaDR268TZlswuvhUXB$%B`cut%I=gcBIFd}HGJ@QiHY_a;B^+# zmm;_%vG92^wJq=1=sdC-@KbohF=RLova|=C&Yr>7Vn3f=Y_}5mveb>2PCmP4*+7F% zr48QiS3SK2jcaT zD7J)NWJ%V~2Y`cdfugyi%Cc2f*odaJB9(WXT?_fIn2iw^NLb_dzqce4Rgfc92RlTR zg({t0{8->P21(JMq&=ljd;H|_6FG{98|`R`cmI;Ky0*ehxSK~}Q;;nf;-*oR?g+d23b}B`^i~3lm)wi zz-igL^t{9(jV#?(!69FoS5*S3e=D{v??I*O4)0pNOIg}a^H_pKmR1z86a8nCL~VJM z0_tAG#f1ke<*l(wm5Qh9X1ZhUFJIL!mSxGFrY#6>U3N1)SYcT4qcNUP)~&22s+4X61XsnIUY7vO01QtvYM6mAd@Z5sDuV6GEx&795j$+U z6D1U*6$bNF1@x*t+4*Q2?h&`sq0qpx?}g3x!3ni9n_j>n`0r!@r&93}RoyWl@OT>c zhKXi)#M3Go;l@id_7;ybMCAW>#DW?O{$FDUQwKX@EDVj!0)_=a_X&l)Kb}qX@mFf= z-P53K8)+K#CY#8ogEt(6FS(lvIx@Z4Kj@Gf(=VFi;YD6de+Jo3eE$TiQ(Wl z*4-JyJ8^N|i9`bmdC3SbnINqlcJU=?g*1F;1sftf3G~n|!h{;cKV-sZ{84`ShmLma zx$#w{AYCP9c-g%Ly0FeO;Ni0AnQ|=Rv*o|NncbGYDkA#-zkXHxGxIuNX<9tr=aS36 zI0fH(0zY>Kv8GDD>%gcK9%o~pBk5J|8^e>dEHS;;QH;58UIAC1Xh1ey!^pSpY;2DG z%V$xWb`bMigU>!UKs|{0EE}fTrE<)z=gFqGRFmBrU)y$7R3DS8VQf-!;=(Fa1K5mI z4d`vwQ6)^{391ilNyInAXJo2@dSeIt##k=IbBliSX|-%Aovor3j*9<{>!MLq z5lP9Sslkl$zGePZG$eDeli$Ucjq372i0}}#>uOUA+zl12%Tl%5u85n|6&LD^vCBT4 z7)thKIjs%3k%D6}Vf)NpQsZ-%o9g7agw4*~cOHHLdEgkzC5{`1_y82VRvK|#ScEEF zTV7OGkVE&6;hz8#0PX1rE1I9@T5;8#;>K;ls6!#dV4ULA(mJ6EwPGOL^F z0DG^#gzq5FIWPtrL^p+JLiB+*|I0wp5C)OZx|ofpIW~DW5E6)+4u{xH%ep4M!gz}E zA%@2h2B06{mE&Gh`=8N_0Gr`)Hwu$GPJ(#LbqJoNGiRZ2>k>*yUDw9A5p-pRPIwyx zV~}45>3LF2;T!6ly4vkDHO*M)g(H!$kb~2t%Zg-k(M=N%p$Vh>450m87i3!Q^s%X4 zKiq=%{d`91E&0Vq$NKefugPk+MVEA>D2)@L4M3~2 zP}0P(%NGMe_9$X_hOQZ?txmEx)Z;bew$Q54J9Rrj6}HKg-aSJ$PKRm&EX20l09IAe z|6w1=hU$mN4yOzODYl1^f|qHl!@qoMTNicw$so$->4UhYc`OG91Bv>tzbi)Eh_ae| z39UYz3L>gGb1!CYdJ<^@cwy;B=OJ4U)}j*-J@vE?AL8LGktrXDoh&Z9g2d9l+r}qF zW%*w+*dCiQ{CB%TC=XaJFOvSH48t+WKcoZGpM8cAT4gk1SpwlEVyj^6g$PL?4ukwJ z^GT$RyAR2PiPmYJ`Q&uXuws~2pz}VCE*We%Rn%T*RoL06kvgZoVF2OsJWRWvkH#>v z-Z0triS$w(E3D7dA|orR>Pj<%M%j@rT|&b)H~TW&>G95P2R84)Y&ewGCb>{?A>dhg z3vQ`=lB@Oag)%=+DYc5xS9%|nyICSkG$PNa-QNDI&dF)_#mq#{N?`9Nra90LimRX7(vI5^y8@}tf;ci7w%u0PgkX@R=IQS z|2jnL0%Gg&6aBQsr=;}b_Lg$uHOCehSG~0jc-U3?u-0>JtKlP84J8{J7BOGjOR$#j zYsFB}>-83fYC9>`a(As5Dq_<@hwAY{EO%tB>&sZnF|us7JMT^p7dltvNEvX3_kVL7 zECU41i8Du;HZDDxqDqg;KUs_i zBU7QR|FrBgG>j%3-ivsk-9wWsUM=1(xV*L4I{dGgvMrU5hjE%2`O&;s{qo(x?&<#F z!HKy>ORsVs2#bv;iqU3F{m7wO=xwUsb#|GJ@5^VZNM#rw2XITfAow7Q!p8%nQMgQ7 z?<-=dJ@#yEU@hIWU0*xGm?8yWLRkJbjFl=Mp8sBNEJt*ogm%um(Yb=Vo(usH7o zr)i)KR}L4K${=f|rDdGn?&&|G{`8~s)uhT=GBR3s6c}lGu}-gDFk<9RsbPiY%Lobj@y!I>O_&@6PVErI2^M#7_puE z&DA@*{(w#$J#=kDIKur+s1FH5b)7T z`k_=d2}PMKbuKA$Wz#_Bk9vcns$iVX&T2Uux012aRG2MWZP~ng1z}hF9L!g3D~2T) zEWJYV5$BdpyS;xWliXNMXDH=W-Ca`EK>bC^i`m6R>ju)jpe5G)P^{sRKmMuE%_Zh75!4403wW{7%(;;)*S+l$EWc zP`1soo(o%dDv;o-f9#8Wwf3wDZno+LH9WXqOBA)8J00U1q9faH}XvO(f(i?FdBfJU&&5Oa~ z#Hlm+rS~hT)ZM5Q8tr1aI#e6D6*zUs31Bvv0Lt>kG)30E{o@Yl4!SQ6PhaZ+DtTi; zi>!}`yyDl01^D;(q#;&cTg#D)bp>3FETeIV+G*iqHy(cvTD~mHU`n34U^kP39$^?x+Mn%gTwF`OEsw!GQZi zXl~-dr8zY;%_D`?&*pOPW#ZMArK40CqC51Pj|fJmf*R<~AxWZntU64tj+vr>;oT_l z$If8@iXVa1&TIJi932}UuM(#A@fbW>eFvrraBG~B zpZ>5IPm(ddFR=Ij)P{kuOjN|C(^c6?E*4vCPpm8Oxb+XaO@Kv8Sdp4IZGTxl{;yz(Tc%vU7YW*>S}J2MA|g@NA6PL zho?FX5noR@WP`BknJ7*=$A9k}+qAZrd@$%OA4EEslje%&CV^E{eOJz5f6PUNUBl%9 zq@D%HG&he7;~-&OLz!rEA;vPiS&H)@L)kRXqXN@2G?RH)+w0G>}>~3^6jZ?r^kwavo->{EOc%D3YME}BL{rh<9$&+vY(0=szQG4s#C+)2*c)#^< z^HKW`o3}D!>zQF*Na%8s=hL!sRp0H&{YD<9!w#&oQg36}7Wh|$1;7mqdn0<2_9pS< zn)~fzB!NkKeldm9Y&F{2Y(H$le;!3U6R5f~h(|HVWbpugd>_NBzxLt*MpN48CC{~} zYg)V5B?V9_^0VnxJV~~r>wHF69wrI216)yWHl@g4aW;5B0c2q7QSdX229^yHO8FN} zlgX$M1Ale!E_wqeCwyaccqp=CzDfHq^MpdY;hW-u9B72P{v{6OgbyWpiOFio{Iwk= zDc(dtS0v)9wl>+HQyf3t!^p>E*Qbzh!+5GHZ-haiW=sy*Q(|_;c!)s5 zFyAXYzu8@ov)K?O3Ji!tROs;CX|!|jQ}pA`@$t^V=}+6_B875Ff^qoi&>xM5n5F?H zH-UvBXQQ{Bu1^eJ>0m{&z742vJjaKyd&(UcDz)Yee zOwJjtM<+9E;o-y0R`de6Q<7lTqPIKI=2pAiUT;6#{I(UnJK14jg|w?c=aYOkju?%` z^AKONZ~tLM|CDC^;cSpZOR#;<(({drCGF++eN+r?Ts+ra@pK;6y8%ii_)=?;b^Cz* zgAF^MkS+0lxJ*OuyTM9~AE6o4O<7{(f>J30Qvtc6M9jismxAFZ;=8yk_0+^!G`A3aD& zDlUMD!N8dKx0!r|(N$;ooDeuWUXV{54sTlvqZri<457tI0M0fpit)uHE~+zcnN_2; zemcHjq39Y{y&Rm?uBXiqsxiK>s9iIjO)t8AI01UNU+LFbJq789JRL-9R0H+CK3ygO zKQDaf)q)g2W_wKT9WO`j2odUp?t0U#y?gUp6Q-BM%VfVd5AYBD z@%73wtBkP;WGgZhA$z5JG~-j2u#q~n=HseHgXe?_wapr#EVGfCYu)3`0F~I`(Nd3A z%U;q7)8H90wClnk6NgDja=+~-k$h6{eDEHuUX0hr*(2ofdDFi7diiCUsG8Tk@ zl<(|8^xZ1?gYN&GBC;^lS&amhv#B}ESD-R)=fQW;Hx72I88{6**W;jyFRL~7CtmK9 zvq580FFmi#58G|-bzZ!CWnHV=lf?ch-s&QQ>sJUF`iCuF3pZ8NyT)vJxUSazvO(kh zDxqY4GMA)R;v^5{tIDAHPvZGy4NYXGnDzo=!I(t)Xn8mOBM~5Bi|VgSQ!{!9~{N@6!Y13zDt`l z4~$Py+3QJnVq!jlQhKoPug{bu$vPUv=V@OS)-((19cTLeVrWJy56pXu#ma*BZS&_A z{`~k79!I)W3}#6FWu9J}!Ov`R!Rq~dG{S2vb=09k_#Xqe4Rvj)IYZfMj4@CTk2(jq z-(Gii_JCD=(RsChAS12&KCaFufgNC!BegyCUAqFp_(c*AfDAYqw|q9$$uuI~H_u9k z$BJKFU}^{`{`2N9I7G~s5G^l9U#76F;(oHS0svZN-wg&8UVZb8aWZ5B1~d47FUUFv zdm2cnc=eUBdQdsb^JxvJ@T574b$mT>V z!K#M&bBdZJR>WkKQUQ2127P|4A}-{%DX+566mdDt_#_?Xz~N%=KpYYXhWJAK`KyYp&)cNG`CwCXaE$?_sKm9ooqG_cDx^{vZ9e#?t+ z5?WD+6Vei4`)12M)66!N%WV=}2K&feH;3qIOS*WH+lx_s07I!9zTNo#!OKHSxW*pv zfb#V8R8s(gA3R@c*8b9OX&_*z8XaF zhd3Rg|JLeK%jn++L7}qQKZ~x|bzI_QlLA|#E`Vp%uI~IpMExd^GfB#Z2ZoV+Lx|K~!nkTlEZdB8@PHBvRQsWx8^lLMuM31XBq32)%U~nHF zib4h;Lop$X0Bt~$zh>iz%T6uERszN#yQ6uC=%};l0MA6cK z^v6=n(Ei>EuMFN6P?8C3OI4>Hxw8)f{Un3KC7(=^{*=)FDxVDgQjeFZawDGxG35LOV%DaY|Hv7(n7w^;}%wi~j2B}S$J?;kjXIosXz?}W;Lp)3eV)C{+ z*jy#GQonuyFQ3{Rx06Gu!d8Nh$FBTqh{V)r--{mjIE2l)o+fdKaZe6r+2&65$uu__ z?}cH?{=|=E_r1yBaXl@`X)t z%Qj9NPv3mE$0{xSOU2-5a8!DI%z{Em$rYi;T@^7MVJ#?tT1g$|+2qs+fu&aWD_fYV z*KD!OTcN=qD)G7Lgv=uZ(fijDT9av>hV;U-lQCd&l4dDWWjDWfA;ol7=8hufBEE3>_}YH3tI`(@Sg%lc1aaD4W>vdh%=ylUiR z#fYzRk>cm$Cw7q%oM@Gclos{D(jDDS6`%63o(t6i9NFr4VV#S}8X*JYAUR7jc7gin z`0(^__wWra0z13%*%Skqq*Jm7KLv%+4>WOw<-gAxrfE~wWtk^a{VX5ACcZgL3FCXv-hiYu0b7FiHv5Ba4jtk{a32GQ|q>!}*Cxl&n2 zyl$nU$~!1^@P4U6VF~8w%Sy?B{1A{MjC(@_peAr3=d6$bXg*q521J*{9R6NyMVs2e z{AGUWh6-{TUc4dK?E^#PNt5MrwB-aK(lv&)^+04l4Sz=9lzy#s5hpMs$LQ%(M9cW* zUSrc-{URi}@v{L8*=6;mCA0bs$FVbz)tOA>4Yh=vr4gnjtOKmHNDqqqp|C(#QG5phKh*z6SE>6{4pzn2X2D~#)M6<>?m z3@GILX~cmHnPb1gPHb-~-+eWYQPyvh^{0cj;mBYq{^Bhuw^O+?icDFt=|oTlIHM?3 zto+E|RHj>z<@{HN`~y})U>A8cDFnM{Ke0Mt#e!n4Zjt5V@fnuG!|;(szZeDUtjMDn zo<$-THZ1R^5HOcAHWPIW;jj?gp(6eboA07;n%`AM4#a~<(>A3~k z4PFDaq%YBJMY+&it7qYLIunxR9EOdC?q~Qc#YxfL`fk17>sMtrl2y3Mvu5#T@8pkBFC2`TFtQig9qK<%nSv6&8MKGYfg}i>tstBIDmi@Mxb0}#B zhJ)_CbX}jF(y5k~rgU0j-K)E=&@j~wnd-21J-SEIOEVH^=vISuCahF~z%zb#Ts`d~ zN*#t1U4bbcA@YLccwz+p*7}?zlz-1)x98lgQ+mqws`vU-NsIr?%31@U%wO5PmQ>M} zUt@@45Nhicrq5V~cVg|d8#Q#D#*b)~E6P+r)y#*BI8?JP;&8o->np0Y%_?|H>0v5d z1^tvZBJ05%AoU5*zz=1S^QXG+p{*6e=(#u{~O=*U!Z@O?a;IMWHcJ=!Qh^=%?k zqLUVrtMsw7ohSua_Blm%Ltc^AJ?}Z)O3mD40DP(GzKz(yHRAtLGH{_n%h zCtF*O?D)U%^4rhxfA8SY;{Wn>j@F~2ANHd(I|DwS9AYp?Hwy{LR3mR>h}yYB18+WD zhyVN;)h$kRU~l<9uVXx6DxVD|NnAuH{fjI~F~aZnagqI%4S$plFE{eZ`EzeP;y<(P z2aTM>7jYIxM=-^BKrg>9=+$2*$>1WMZuIlf=b*%&gA#uZN-TmB|0zAoFo{bSh(mYx z_@|@O!|v-Z{>03w*4v7(#HHbbd7=fD^3w`u%+%V$2jgU91~3*Mk`Lp+hwL1N8TdAt zun%XPRejU_d*}EBQ&Szhd;6kujGEJr4>@6f<7r_~#Qvry`~%AKzImWQx$sx*1MX4a z)WCPD3rtKp9I!4#(t*Gn_!{C8zTWwJrz?tec5xY9p!8L%fqHuH6`3Z(7bS=-0B_ePJXi@g zowz#(Gc3de#ZN<0J2nbW%)%3`a2@L5Cjz@5m_(_i}Xy<4jBb2jK zoU@IL7vRQvZv4jca+V>r$7|()nVnqiF>8QM88MD14EC25xpKJ;KVRAV1Jv|(grBz_lmCCT8U1REzoiH!5le|YbP0EQ_MK4n5C^bw z*@~734ofZ8a4Xt+%`?XPSsYv=` zC^u;@RTc#TKT4qN2T@iBJX^7Y{k`r#{@i`C)m4SJb+brdqz}J)WOZLUU?@H*AA~Gb zr}xKO?IyiL@fy8TDZTgL>ghQ9Ydv1@cR@;gxf-0Uc*%1S==8;1u?y?(r`C$r*6@O;z&t*365dZkGnMmG`GBRlScZzO(jr z4-W*4-W}{7zCAkboSbyZ48ZtMkcsjl<&pLxoByS022jvRiS8PJEkkOPdkd zVa|fe@*ePi`OIyl)CgVfu5TDgYjeH&t$$_&PKN_Vh;`jfO9^Az9!kt#A8DWcwkZ<= zQ6n6N_Q)rFn-@;Rb&wbPub`i3tp}6Rv?D@d(XY0%MnwfE-_zf-bC1N?E{}$M$d%Mw zcuxmgbWS2G!D>>0qn+cOx7`cO5^$*m_xUBt*dBEfN8`;uU=yn>7Rh+ zNLTVvxv@^Gk@D+`qH+EH$OBw91mu2;2!9pPub}xh*$!XYb;={XttxI2ZOaW^&W4nj zW0yKxAOJk&5XWn^>_QUJ*TD>(dSbi=KNcEN0WY_>wn(i=^y(jrXVCtkaXJ;;)S@v~ z&Rz3TMX|SA4?vVpwhj^OF$5D;!vIQ84f@3a8&uDnhr5yuhp!*Dn>uONiLFV9ooiaE zq-_WhK61L&(`sxygSFC>pQ^bQFN!l_<(b0wVCQY8!KG1kG)N~y^~&{IZTm)FI(VP~ z$+X7kkKVn&)oFTZ)*=h;)?dIBUL2GT{CNNGG;%sK>vgC4OFoP_GlrQfSC%@vcz;v% zwyex1Eu|8N{~hh@AA30gP8&oM)+KV}M_>p~YgN?h;hv~-=4+z9h-ci0)%?s_mUEB` z9`dDAj3B`FFk7w#A+%`Ya$*7%^sxv-#-4u?M&}|LX zvE268efehR6<<-q^bn{5W zwqEVrsm8-UVM@F+tVEYLG@Zm*aR!u@C1(L}MtSdFnASiK zP1@&ZTL?%CWNq;l;eVdE7e0s2I|G5l49Nm<%n;jjSsiTNj+CzAj>(8dF-aHszxx=8zp1m^W`l(fDZDIwy|z|GsnDanikI+SV4}b=N?_ zSeEt!IWS~v*yR8hUDO4671-I~k(Ep<0Q=I(sK5SXdZP*M3_#gMId9C7y@dx(OK>L6 z;s>LNcrl<3KP5^V&KUS#=VU)V*?AiL(q6!!pQ$rk%knu0pW_)G*$Muqjy}Q|g65u$ z_o{&L-92fyyYG(o_04`7U$QGj`1w!mHcKZP7x?a)Qh;d?lmfbcYsn5Mccsg{NwkoB zIH1NPIkTOgU5seYg_8IX`m=22VxBu#cUSgTRDj2&qv0<9gBay!ioN zNBZJ;=<_sM<5F0#F}%;?iHZY2+5 z5^dCC-_q98e$x*0gf$UQ#)+$-a`4NCm7L7VQt!Q`IQiwJJR=sP=Dli2%sS9su(oO< zc3{|68SkKtGJzrEv!E@&7B!O;lFifH4{rZ!O}B`KQQ9uiI&Vdx$u`+CpBnD|U!^kd z1M^%i6a74G1n}*=+&k}15iM6lHsrqnihpmMUNLch$ zPd65$f2+<8%GUv(2Wv7t<@$3TxzWZzCAbK)T3QItJ<50M7gjV!8EaL!FHCrunmJzR zW7V6vsmL+595cLze=ie!JVb#ClLev%q#2O1U zWHe&kHWZn0kXvyb5Q(u%Kn`C0&li6bP6CazpYl$J?v0~-CRh)}&kuiLLzTzu?&&{( z>h-4|^|KdV5=B!NBblmU3AoWELpvo?oS@3?$>YZlzpd%b*JyHFAE>Ewg-~TGdKn}R zhz?P-pQObGB^F3<)N(b*N${g4qsf(MMM@7R+NJeQR?YCH-ve8X@{JmjKh%t#{7Nm6 z;5^LhGA1hopJBjVieHOM<#FB7JQ-0fw$Xw?RK#CjH+WS=;g$$vlXlZ=(M6QpfN!@a+p|z)8q?S+$MoS*Vih}s38KrNX!JTWzS}d{^7MK7;w#+s=t0d!*pw1H1agAe9^Sp zDg`a;_e7n*b_zws!be+uQ-|MdadrQV^1WSWFwg1@rO81m{Ml`1G4DYe`h0GG#trwL z61+ZBI0}1gYxB`}(O=L_D|#AHL=pQikq!IyTfm>9Y)NXf2zxe*Kyn7vuHU1F&eHVn z;uxga);a~pb033L{k^D8fBXhdL;UXpnez=b92;4wg6F2(J~te!8STw( zwQ4%$XZ3m6CLm#sZ35Y=vk}e%8)5!Ye^FgM%uSxpv5n4ef*eSB5L$C#$~nUnOC?w} za9`9vd>qbuAyW=kt}B+i{8~uW>*eDDH{2A3ihd6_+uS>9!Fy@-Lu_I*!a3c5msodF zH%R@xfk(QgJskMQsKUMVLm|R`8;kV(nRk`UKz!zU@W6)k*F-#;;zzEAG?tXEh7~cX z<}y%-wcqtJ&%|XG*y|UT@M|Pzl}Bg)S**Kq)4l}S7^RGuq(z=lUXnaZR5o9>1UkRU zN+7a*w~`*TaX1=-gA-r9Cr!0kdeV$y#n zGwd*X5 z>{HaAf12LDkPe8f=p^L7J(7O#fj;aZs=cHpRyxS?fwI9?zp>awR;UTj8NS06`r5uF zvX&qnN{}#R^tQ8A(#}?mc0?FBdptb6SDm4VChVc`Cbp~qVfsV%VdJI$|bMm4-;%gE_;xrDxWx;eD#}(6U(Rh_>G-s zOb6)IC;wKD9@~M~ds^6q@PYogk1@NE0;@9^0({Shc`qIguS>f%JcRKnOL}7j5H^wz zYQaK9Kzrd%I?cP|WaNnxR%0s}`CVjo#yU0K?3ncHEUQzQ<-DW{l(o@KV9^8E8iw*0 z?_PG_cHUAdP4mP4VYD_%MqW23%vxhv+>MZEtR6H$ZcF%Y(S>&_dbBz!Q$I3VFx(iy zdvVIRaoF!lJap0pl=9*+qX&w|IswcrUnJ8u419;$Zb>IMtMf(d*;^C&KQZu*P2f## z0=#>4XzW=+P)iqoQbYKmBa&Fy1&Kg6zrN>LM-R$~4lKqJZ|laBO9HoyI)HZRI$pMJE`etCI?!VAKFHEFP8f zroWB#s^#qPnJC$xR zD@c;_n} z<94ojS4^vT3A3zUZIjh$a1}0c;97TX%K&)3xK03pPXcU2zBnnm?XB;+{a$~ip0YK% zQ(()kIJVZWNuE<{tC89(tNP}(ZmcM7&`=PS?Q`$$M3oUD2P|24Je|Z_k86TC-=snNtfG5f56&4bJ~`I>KAzreQ#Dh*F9{ zLsgUs=T3!T(yL}B1*{HlWHN;y^sP3uCS+6tJt=~&_oPcuJy_=_kBmIZy(f>lwRgq* z3eX#>K!Zw9N1xe9!G-?RYxeb54Ewb<(O%XP6-#W6OfHSqgln>$0+db7{#t4tsSrIR zhb?$kw^NJj_7$zegJ~Lc1Bkk}CvlwJB=TG$Fmlxg)X?ums0ITU=NSi+~TG2%cTQO%HrW7boJ*xv8Is_;|zW!0K?#Kr}0Wt;f5_$jQk) z280M&<(|S49Kbvz0b#GkP}P6+;rWm5rme29&EP$lf@HKz{PXgg4#inIiYEn`ixl4* zknftybspOXVHr1lNNSJNxtk6c!8g*b$RgyO(O8GiZ$zjYo0>(!iu+R%@2Vao8$z=d zM16vCNpL0k!b5OCJX96zSVa;-$8&*s;sNuqAIv2o&VMstuBSiqtO3BJ#u{{X!(kME z8!Ff;mASmCWMGV@#kP>9G#cHfLmRIiYi_)e#WA3u;$g{jk9o0(kL70Xcz6|G7o5Hp z5vpp`ML9K`H6Hr9$fK)729G{V&u4H7<}4mIu(p#4MtUWD73bsc1JC#tG_!6_^R9sD ziZGLys=mr<97UT@14Luiu9pw2h1A*&Nrk{0US*;aNB-5C%RE!e7-Wb^}-v{SzA z_O*WK1sss5A6wC^B$q1iww z`-tUZLXU?Fad<*_ZCW49 z2hMNGQIU3>16{r~(yT}aiMjW_sHYL<0edCJknX06nLXKg+3CJK?sNnLqpCV5f)-7c z?`@tV+YYB%!dvLBvziweRQDGm^qa}zNx;@Ov)x(@zJksdo_suh{xCd74lWvHqa3zw?pl4YVz0_J=NYvXhejQW zq42zAG16(g)+Qg%01ICnsNLP-C6Mg1VlQ9rc8_o#<$)q=b^oyVdhsWFRHlf$aX zVAbTW9QI0Jjh|tPWX98;mM4`?aPhY~tt%Z-J~L4Fje+`I@I<|P&J$$>i{VG)%!`;Z6A@Vr~+HamkEd10Sm+$0t9nJ%~a)(x>En0NY_c z#Q6+rB|0}VH%r!nBFy2op%w>=v#))U>#m_e0rl3%nV@Ts@A3W7V3vby!fg;nA#r0X-HNiddK^iX{3F4`&H05r2U3 z#Jyp%A({}Th^wos4Q_kb$S3Cy26?}D03d8{Y;J5l=ufW4)BFLk zls$K^-U4HG+*Ao<4#&--I>(swUU=(_7crC@ACHUGTa**-IZ3S@Igo;*T(Y=&?yp_apYtwtUSS zB>%v|d5yQk^{bOQxek5ELLbJV59gr|?~M;NatM2<`3(#u#(|{Hla_YQY+FdePm7|_ z1zmN!5RSzo++ z`Lc7&JfT=CmanigTt!dh?#6?Lp@A_YhNzKwVIJ?@kY}sr{HnoC)bZcIEFEnKus*n{ z5lPswo_TxN*~#hg{=qBOneovN(YeRhJa%PNn(QVVfYHpb5b)nJm)}gKB26dDSa}&M zFH0q^Q^mBlEIZ~FHzW`npuR=(85g9DO)Nob2oTd8FHdWtgXhE$IcN)O&~?I+nI7|O z1@&M0ShcfgnD_Bk0?mz`M@7Jj;~A6IX8o8{+?yV6`9=phJ5Zye=pruQ6i>3~ET3fq z`_@J6Y1(WAUN-;^LXMP{`W}M!Z?_8GzuhHx-`_*-@Y{=e|vF ze)G<=dSDNthF4Y5YzWv)H9t6B_3_N5y)^IS{ati&eixl&%{wuEYBE9(*yI&^QzwOY+8TD8B=t3wq}SPLC4Vb3h=;!)Czcdu(_ zhf?GeHE%tcJ(_t#6mriK`F=s77jvyJXMF6)O)Oa%sxy~0edcGe$z-PBN&r-g0?W=PC0*IGLemWZ+yzlKxPPsEFH+uCuXz2&PwjRzNIsg=tm=9+9hd`dB(bPM`1-4dts{xlJrk@7C+D~E{A0?dd%tgw0FsSvvHxka>3Og;p? zc8t+B6W zM+;D>GvRl(&ZR3e51=bo&nr5YX>stW(&XTyv^l@CHCmkAMWA!3l7kLOkBURA)#B6~ z&2eRpg!7`@oQc(3Uuor9$x1RWU+VFVimSrV1EEj7bGOzWwrB1b+z+f69Bs z(DUa{GW=Wu3@*I?-@^U2di0@3L|c%CzBQ{xjoeAN05 zPx(b%^9xq8S%8K-z|Bux`oK)Gbk<4;iPKg;k^fhYUI_$#_)7RRIexW9>hD+C6FY)s z8=nth)jHcxrB^eXK%!EY2Mb&+;?CD_`HjO6bc4r*Uq)Z8d4^QY!+(Uh`huXcpoXTv z?Y`+jpmvZ-8(^I)mKwp^ZHDD( zHE;1$c_YKKiRviZ`dr|>5DmbNjN>xW? zTCHWpry|#sLiJ^zmOd%D{xPV@e3t>>RnbPbB_g z0HHib{V;6h;S3su|9Y~h2!@baZ+sk8OP- zRDfNH(8v(9|C9~bGeAwbKg`d&7sgPDnL6*|By-2`k@0{mqjYHSoNLL)anhf{TsdMPHtFQw4?PzT9B2{_e18i#APXwu z$j81ODe0L*%p!3XYwqBc&W+1jey0Zq1vwguKRt9<=(~b=!pmy|(kXpqbsab)b2&rM zqK~PD=bInk6C9@5bX{T*}IdJ+9QndC`fB$WM##^MwRD1LK>))K3!%^iC{+dVcu zN#Lxdrtw$YpU&c;hHr$?T5m!TX#?OJ(M?MMKv09U_nhGKv^JIY9l?{z6WBR7 zC*^15)@JCyEsWziWIhlrkp+S`S8?)s{5!S`^?N_0J@<7XNKOmiMCad zQlYW3)U732?m&~F2%)g*7$Fpf=g<5i=@si>EtCod2U!>vY}B2PEoG}WR;Ys!W78>O zJTb|zmfc>mx5U@NbTm#yA7Q#Rkk))TKsS`>_qB#+9yanou+A5Uj`dl__jbs3QDtcH z55_vJ^hOl8m`i__^pm29nM?l+q=%Sl=M#KImqGw)aB?89)}p0&@FC8i#u5TmtiC8F zfNOxl3*}{fgr4b=#k&&j{ICy+NW|@Xp;~1tvl!PZBU8!fLOOfdeJiSC!g49t;)d9; zC6&)tFUda!?8rgBnd|f&|1wD;+%Jc>f@a6^Weziswd)z; z$6U5kbM&YUHBF~;7^ZI|G6)Z7!|6-%`uB_xu7cV`$%`H%ZIuPGskxrkh|7}3+J{(I zA583TjYZH&GK$j-=|}H+n$QKnG|PZ?xOeoH0Cf>_Ys#vV#R;p0Pgr#^uW&H$Qws?? zsaK|Li;k5##4Ju!5bPnldZMVUM_5opEi7-F8wd=hhnRh|%_%S_4f3kcqz0 zHKXVz$bP+HqD2sZvm^hIq9JhQtHCNi9}tT8)5D1P0b>kO?XO^V0!5f4GFS(9fDV>da}PBcFDzvG61USODo2Im=A>dC zxGCJkV-q;>G>gO4)blMgy~+KY-U8yj*;*9tfF~T()J&@;d24gL+fZt%yY6o1_;j;I zS?INPS?IjFtP1B=SwuEg$1gFs=>1Q-eYtQZ-rlxjBT_v(W=x3XlP-)VhhrW9#926; zk$t&_o%ZM*_7+p~p?@zsb%BGWb0o#hkZSUd3WDfVIRpp=WBqk)cS!U2&X8IR;iDdhy4 zswG&{3(NFjO|QT+Zjfnobxlh!ms6P0@O{yVT(el?GT_F*@4s5MdgPELDp%19wkF~) z4oc|>s&R;7RIEs|5gpD*n=>L6k3FJ5W-=uRX^CaqXzZgQwB!ukeNxw1HOzIDa9qAm z3s~oXpK`r*p8WpS`Pf|NiEo|nQOKTSnDPf0!bMs{c}$2u3KE zehxsZrMH~CtC!x4eK;F;C&`&g&uQX7Aii5@R4?On$lN%fO_+4nPh?LuvB5%6F|NgJ zahofz6njcT2x6Oi>U;^CRFb;4APwpQ?Ek@WLyz{;`y?8cPBe03vwkxwsJ z^j!)JOfAGCx)yW}UsfJ&F@yiAlOE6|!er^=1EP@8@*`htW^(o0BDmcIU5~!&PNTI| z-`uO+f*_K)HZgY4*~{Y($t;pi{rA6$Wv@}5^TUkU zb;d}RpPa!Qr>G{(_KMmFE(m@#)a$SgC&|<{FKEP(1D&>xV{r0;cjUcQjb9WgGW%IN#ldh+7|>h%H8$}=2=-NDb!g<0r^8i>%bg4YjA?VG)B%IngpUKE zop!SS>L3IW1`X5OZ&|}Lm$Z1GRJo*8V7h$}Db2qJ2=B%NJV*%?cQIYw-|gc?V7@O? z;H0Zo{x&AgI=+L&W+z?fJ^((>oq$(KmP{Dutc8Cm^MkbxRCzEUH$zb_U`WW0Ij6(? zu7KVZz75~!Qa2Sf2lJo~DLPH`F!Tjn zG!_a|Y)h#O8tDsEhfMa?{Jn@F{(xgkeNsDD2+~8E1|`xE7Y+44cqUe@G2rYUDM=dY z3aqMzmVik=h$tqY(<1s157WW6a%7KkC^ET9i-f5P#NAmoA3^|y;wz45%l@kJCZERz zeqLR{J=GS-awPscIs-UYUe2;UCgc$ts-F+!Et|bO!c2I5Zt1(Ag`A`@%FWY@Nj^Kj zz%cV<77)$MvS~Ur5kNEt)r(ml_sZD}w~oO4FL{9nnxZ1oQa5kQ_xYu+z%caX6vf)3 zzF_yN9qolKIxE!D+FFrsos+CufX8QfIntWY0*I<+O!v}NTQ0vXt%`q>`7|v4Tgf+2 zv*ef6Y8K_`D}d+I2tZ3^3Kw_e^|UV9t&2KJm+InN=Tf(pmQlQMjcWCdz(R%rE~tY7 zilg5Vw;w~NnXRe_M~JsJnWeJ`#l-U0Y7kvMh}t*MTvecKSc&DUSYMxIO@&RznG`Cu z)Ml-#(_-Yawn{5ZFz!aXt)BbR?Ha_k^X492SJDgi*Aw!BCJ>RdV{j6W{d)EYnM;g^Dd%#_lirzJj+v zsds#3)oO3qg}Ku%%-{Bo9dZTk2F_a70kF)erRwa*ha;FoTl}q~Z7EJ`onXD~0IWWZ zL!THR9J0beM|qE(r5{B&4$WJP&jktxrc&-k6Jl^eXB!tRgkl31`kd>41sfis3(1FZ z7fFe+JftER*VGXZ&0zWnt`_8swB=4^mXvwBeFf!lFb@MbR!p9l47rr0gMb^E&T%f9 z0kl237S9TL;$P5`>L36x0zPz8WWUDhh@rRtu9`45p2CUu??m4v5y!(c&py?( zX~vib%j9YoHgU1j^l9JrT>YNF5jU>;{TQ2g5I2W{@Ydp{Zt^7%0MYy#yh$X==En7I zO{W%gZ(Z=rq>x)(%TNi>;lEgJWj#>XIZ1lw}byv2@jZzzS?)crD64J{$F}nMHjfih z$%7E9ZYWq86p0D@uEVL}&o+n8X%w&sVSAM|IbU_*O;%z(^F%x{*geC)bAA_qI?;ea zM(mpzsbw=Y;sY7Ylm-ea4>F^tbyMz+*&UhN-rqBXv{HDuXFF&8kY)EdQF5Vh~! zrPa3>NWjUT$oCVhPfpib;~o?f*H(i8l-LDd9-~{Ev(S8h$kT!QRcd!N{e!U*q40gt zGoQjl`4a5q+-WAA(q%&UPhaX_+DjL@>YNbP)neo>cNahQM9x|>IuQmXpH z5+O5lbiDufozsq^ykmIW#T{>m3as;%BtOD_qbW7SY@1wJ^G6`WXK6Q|4F}|>frBaG zN(o`AI8)yZH4A(UgyJt>>>>i(yBBZvcgx|X1cLu%uvOmJ3x=O0YOm)*9W1pJ#jV1B zwjhF3TkK%~$mKgpDVjyj%S-LrG@*x{^>U7QI*hdIqNNHYW8a>y9}c1fO^)J8L0Oq+ zy*tB^y0`1`@sMSJ$98agDs}5_I5yusIxTMy8blm>CbnoXF)V~>6hY)}P{w;<*o!mr zPt4j02P{961TkRo6nQk?cz6|G7o6uWA~d~`292y$s;f0xH4umL=qdpWU z-0!cSPbL_To$wGNA$gEf*gse}M-Tcu+Mvn^DwoRTajG8 zv>V>oAHk(@uX5KT{pzkZEK;h5AbfdfUfyfk0fJoPWZ-d8__b~M(uoHw-x`8Hz0gAe zuWF^whVgl!Xjb>-o1IsjU5Nf`y_J%saWZwSl@wf>zKU8`|F!#KrNxvR9YU8fm>Zr& z_g20bA|HLJ;v#wE3OO4=C+XkqQh5X6pB8*a%I&B$F}MKt2oyIsJQQTQSvv4hBY3Sv zo^ps-g9e&WGt(85L~$0XCy*%%cXvg=1+i`EJs(X&shiam$-{Ntwrs(?rQnf z(_(Ecg&EVO$*=HbpI;^GzQ%8V`25`2GfaD^NgJiee61H#yymdJxzXNyP)zy{G=llImYyx-b<*naqj%>~Xg_{?C=6X3vspVDPE2_ONVsZiDH9l z(Xrm7Jxp%Hi|*#*>q&ZkF^yLGtI^hG`%%=pj&>$cac2;Z;%u761G;j?8aCR%=8^OO zSAI6ViYLi-be+#Yw!;fNPzyNx-fRk^nBskm2f#3nav(0(6y*lZSc7Cjfl}U2FdIsVi#41T>A{&_JN=#sBtHbv$z0K+@t2O;!7OL2_H)IGKcobv1B_+Qq(-- zeSiY51#NA#MQ6Op7IL#I@f62T>h*k#HCJKW*AZF?WaW)8DAbJciW4<|0Y?D*0S%{9 zcCawt{j=Gy6+uaC390bmyVGdr;HLoWKoh?RSnT7SgVUe3$<%;yP4a;sPw8kp#JdbI zxd|-GHO}B|=Xm!ul;3%=|7QR6CmQ%9dbxjk&^bAYULGDtJJHe3@#+5VyEi+>(b2o( zqr;QV2C()?QVwfuN`U)}77jorQRY^#$Qw(#)bW-EG;7taxc?Kfr#>JBUl96tt(fGmlo&;j=N3q#`-&hb1>TDiIK536F_YFcjagGWI%O*aD zlh8c=J5Kk^+TPrcrz|~He{wyZa$~$`37Q$l>11VXe(#SpA7Gr=0=05gnryS4HR@J9 z7bIdCw&*6V3XWeupj=Z&2F-oJMr!<9I`6PeqFz3E1aAjsCRHBIM&cYc8hspY%Eo-HePY!ZpSyS*{f}H{;G1^oPw56O!krYK)jyxrKcCex6Z< zO_kz}uLOEJt->BI82P5va^en&?O<%ovh}`s>y?Y*?LtIovU^}Opknx5e}KEwY?faJ z*~O4wlf=Bg&teB&Q}nRp{VX1O?si9QEL%Yq@L9;g zqDHdD&X}shg&;H z*grX4tDZ=0Y87s(d03}9tIwIpP`53w%M}Esp!mL*{%QH07b@xZA*Bu|bn30$CrGm>j(Wqq$L%;99Dm{iKO#kNuyeYUrv=o+QjQXb>AJw{mW{PgQdYy;9d|t6dmQ^ z7AE#Fm%glyNCjlo@S&6?y7AbB<#@wWPQ+R`Q^FIv@g6JnxEA``MhP_g8bO1Ba(_rB z4rZ7gqy+kiiNGx<-<(P}$CYT7KaC7RArZx}z#9=ZSPK{p6AN1=@ER(tAJMs;xrpj6 z?!I%(2$5e*^9fU9^Jtt>heZil$-N_q&!0p_Tc%e`1EH$6$IYYMMZF9=H2%7+q>P$#Ye zM_;Gak{#_vzE;(YQ@X1E8tw&_g3!&0g4FNi^mzZ^6+06}^RDu@B)|yYRyFiPL>F9Q zLn!8w8s8~}=oAC*ml)DVDRE**VRw4tb4!oRl8+>D^3$W1j}l2D#e95J5{FQTbbV=X zJp-O!wN?IT9Cx6Oy+4h<`uA+96`8Se<~9Qq!GuF73FmNe|JZ6j+1h&K-2Zvf{`Rx~#~nP%|3j>^)EZ!F z6HP$6fZs!;&5Tjv#c%EkviWcw{_|(AGl*OG&rrDCj&`!aB#DdYq<@hmDf)MO9~aqQ znZMsC9bRtalk?|R3%lfb@+3NMZ^G+A61^JrUVnBu`RsD?+2y3%A;K49|x|LsKIZOYeprTlegXRmYIebITfe-JIL zOC~w@<82!-siM}lPs&)?cct!lHyxLw_k9&2inmv|RW7z?MeRg*1)-^lz*3;ol zY9Rvn!!6_e(ay=q(d*-#lMegb-rRa53+$X6w7dHUr=3@w<7mr#{bK)=3x?4{^ULAx zX-9su8asUPe>%IT-Tl4J!Rh|XeQ5THS>UAew|AX`-A?rAJNW_c&Oh#+?7TT8kEidx z_@Y3aM4xmt6jm(#V8k@MNa6wN0_~iBA6ir;{Xk)ZNy??)+x(Azi9cA*IbipTWV(XY zfP(N^SOf{@N=i2?q7)=%_6h#}<{Ke9qqMQY#_{vkTKY@${8{w%=GUueIx^mW5AXl{ zHTT7eqJLooRPFOR*5a<}=q&DScPG&9%hGmtzK*_u^{#3>4m5sN+IVa?{)Hi4t+%&* zVEU#V0u+9+Ky_*KiUlfwC0cjEC0c)3(RwAwL>Dg5L>FfjUDO5Kho1q^&!UxoMc;oP zJz9lI6!QxORl};ww~Ej#(^f#W=%h=izJivw_1`J&6SW;$SVHX! zY+;+f!vDfZzhgzdc}Dp}e}*0N3j@ct8aVah89MN|ZHkpe+74UwZw-}{C3e=#>1h1( zqhDyy!poBD@3C1D-MJ1QO19do#w`v7R<7cr08`N7Caie`;+rVQv@`t6GJY{NGS6|n z{$s8yKGnS4MIDgEf$*%kTMTLlwI*#&55#=*4 zr|1(CEwMT1$byxnzQ?$_5-8hVm5|~+(3+@))ihpWX?+$Qa|zMoiVa;?m`x|1#pV&K z41}(;_R%s6Rn6BQ9X~{NKGnOU_e8i+0-9$gqH6bama*vd)yOR<++t zry|gv+l|KrG!@q(y_n?Sl3R3^VI*hRC~*NI%-Yzh=2PKTVxdVrY?QRPu?nLG)0~!K zX#h_H4GJrga?H&8Q_P-_VOnA4sgcb_Jpem}ccPS{XzUM z8(M?uAtUg4v05kM;p0A@$xbG6)(>8-4$nR*d?CfB{TYSx!^ztN5uhI9Jgh~NJL z{H9j||8PFALI55Xb$t(HR?kwWr)X{p7E1A&*ypj5kw|kE<&ERO@?r4^l=4U7&5>mhE z9H7kkpUq#5(rVA^Z~o=H84bFCF5P4_o?a`#@n1}E)ITz64w5Y&>UJbRPf55(gU2k1 zp0;AXMBA3gtewPqXR185J7XDpF$*)Be=9NpAZV<4ci$Sl*`wVqEh=9}ouz@*3l4@Y zt*Hq!k}YBRGfMU=#yuJce=l8MrJ#xm3Y5~#`E4UzY3Zsg=`&}=+Wq-ohzuM{(q9C5 z^6!17jG*KcBBWM-n8cYkj+PaS-r97wBOk`<oZ^4u{&uad(nH`$eM4Y@5|4HL6YA zYApU|RYegc^a~Cv8iA2;L$vR{G;?=YghIvm9wcNZSRq0>JkObKa|BGcyWP8GK|DNK zQgds6D6OthZHC$SBA!hzx_vlXdU5|U>i2@RS-KKnUM5sIR7}_If>hCGs6xLL?fluJ z(Dul_#R^WcrOmD7)7Fz-8vb8^&x}Cwy+_BRXrUxwYzX?*2GN}Di(O=Ze%bVF zrE*wH82>)vhuEq)J~?mq(9_!mwv{e1%U7$Yf+x4umO$xMeU5(M>dQs3Z;_$&LzQPcy&qMLK>?47S$#?mg$u6$0u8NiN z_b;e|7y+?1!9J?@H1VWjK!Ijtx(|II{b3Hoko_>ZA8mz%LzTC?(xEfjs(kgK@T$E% zts&TlQHZQwc9~MX+@yrn*h@tn@!guD#cLj7ye6ozO=Xbonmip9*KJicRUYSsq%&$L zsEdAx+xSb^LK$8$TiWZKtatW057&2J?83ejb7^mpDT1vXjT_Js4cy(`{iD~Nwjin51{eUn+z zd|;|2LIvl6F#(^@XDKv?%sS{FpgAUx_*TYfWu>D=gn<-5hwZ`t`jRh5xTW&PYH9NI zHd~_AZPk)#q2Z!}cH(l4E?(84Z^pUH(njNfN7fK$XkKB%mMUEFL2$IT#>tSzw6Ex~ zr++er=(7W{&FingsZ}pIPqX0HBpX=mY8(eu?RsobS{Y~{R6>!aP0v?JrT9l7V480@ z0pxGc+l_C8vluX$1JJ&=Ac3s0bygO-%J7|To?;fIqB1Y=-pPrXK34}OjLG)Q+V&L& zsG3DP2YY5gD{-$g49bF6G7Q@du4EX;Hy8%-*VR{xstA*>vZ_@Dq3j;e93^15InrvSg;UXB(U`o3-7QUx;TTYemaUE?;Ic z`Er#~G+IX9cv*9tc z68Q>vt}rih984C#^qLrCAEcHvvo)B!3lUDQYydbbYSEJcy*YezYlC>_u^H*QZ>f+} z%IX%*(N7vtx>9l#lcj3lFSNH9s`Q1Y?iX4m=*U*?_MSX~dBa@0lOoo#xWzCyL zYdnz0O(aZjItQ$P^V0kdGfh_1UMK$71OMx>|Mh$SYvwW3F8jC@_~?KA!FnB%tEH8U z8Oh}LGK~OR9ZQO8`H)fQ$NXZX*M<8_pF5P;!J7YTa0@%Fe$btc(8bkqI&xHZ&6+3M zoa+tuK{*GTfdM`cZEhniC#U<(UkqApJFI=EL$;hjWhHY?O1=$BzP&H`HZJ+5aJ#(3 zR#}PQw=YUS!xtdag9ax0kAePUtp9lLrc;sgP^IL+*(-eGAbDRCDvhAJrd5>a90j~y znXt6ug5)oWGh-deBv4J5&{w_Hm4yB~p#P5Pzwhb4GyL!Bstj#p;a|4uy0B)efx?NW za1ts!@Dv_|3XeU7$DzXSJ%!(g3eP-+XUZ(97UWkg7Oz&J2U}@{F<|y)WN+=ViMMRx zEj#d*9eB%*y=BMVvhTfR{ckxUmwemu_A&F<@V@AxSXgR$Y6)bLbtil2LmpNETIdx~F&i+}VK|Jd}@ThxhT zmp%8EJ@=Nq_LjZ&mi_20>woJ#k@R>HESLnPnb)0>xPL79fg(B0(!q*;BwY$eS^Xvc z!_ZnkgQR0TH^s>-kP%gY6;f@SrP%>r~HS=>* z9b|BVvU@x5s};3d(K5foq&ncY&f2CT&4@}*bJRmf!|xv5@$jI>`onv?)xP85L65F}=Znf#HDps9 zo}ShKEx|=MaW@i$j)jl@-Go>MTa9BG{6)4p&tAL~7|SfrAnxI<4+R&pka|$%sShZA zo9uRZV}?PtyfFg@yp1`A+i+vXih0ehp1SW2emFS%@j#FUwPq&ctpgeWioh15j7P}| zUmbaA*9Cnw*!kdeda)g@Y5>`)ihH@FssU1~D(*9bOp5Qb>@v%*vL!<6FDikvaHvr0 z>%~R9wJr)Z29MpwJaDqxs0XmRIE9}U3bwgnH8+4Ps5tvjbB`#4n9FM*h$vPm;g$|c zeBsX#!_E?5k?<_RVl53M8tdRYK&npFUn{ym;LX>Cq>5EtAeiUtLeffe4c7g)AoEn5 zE-EVp7sK;Z;;D|~ER%-CCDHjMUMTmg^XY|l2x#k?4w7t|o~0rk^smtxOnnrO$I$c7 zbSFmE`;TXxS{Tq}>7O6B;(vbp?#VwtKKkyTAN$EaKRz7%^W)}2_+K0T_wCZJt#B)_ z6s_nnYo!ORV2wxczfJhPRaz4u9IW}!sJY31{Aw`6-YB{NZB~db%_Zc4OVHSklJ(~t zmQiBfE!Xah%0kAmxV$XbEn8xO{#sZ`tpv9U`?xKRLr~mUXx%mzL^GxTVw=6OA*}jo zbo0x4YF-4h9{;_t3XNNp-zQC;BvzO`{Hrtu0p(cGIv1Jy*!W^>*MLTkm141&4e!hR z()OsVRK(SUXcPrl(gqFGUv+qzE_oCwone*BXdsbceks&Ye*K|p`pf*XMtcv|qT`pl zkN@0$ETY~gg$zpCR)H+aG>icqV@a>23dII0#de*(w2_;Uc=Tw0I^e9k{i4q1$9QwK zyhB={G~A&bLXh{$1UBn1mDJo`a%)WOCTouWHI$=Tlp$Sd$(l1PemF1ni-wHXMGcK+ zjpblO$yHRAY#~#H={}}Xla7cLQUOI@6~gBC-ce_|Po*G-Om|L>d`Ow^x8;SbdG33O{(e=eUzw`25i}>{Bt+19-6F+f zy8_OLq&(wfWGAhxck&n>7;ussvulmPZ$E?Fz1q62V9+si?M9P?5$ z7(CzuyS4d&`Pb!!D-&EBoinv#D(K(r&}s~5-{EyIUaJ%o}dgd0wc6y-Y&Oi!0Ar8Pmv=X5>qVCe*|Jcrpy z?Hh~nCOESBMzz9r+iGxNdT0jE05#(RKEy`RNJ0+ZK4KV8D7S*PD84lzmgp=_hxQ2c zUyUze-7*?aLTfO&hiF_r*iVJVHAWR2k3jF=85ZBp9lk%Mu6f!9OXIEL%j>B>?s_{~ zsz!{9=UJu}=dRv}c?s2TsOT`CTi*8f4dB%z<~A!Yl5{N;vNwS0+(7Zr&w2a5ha}hd z`CzSze~;qfReW7=Ub={o{?dLVB5HQKhJz_uQITT|+zc~O;~>&=%%dlAYxncXBaIMqsbM1e+Ch5&IV;oxuOET`xQb(C4lu`{7kd*X1fOxOPlx9UYp%GLrED! zdC7c`2x69EXqfi6*sMX&$NaTR&O#0#RU&x5ys<3CR`RO>I@+M5WdbTBoH3!4OQCkW zgiC)WYili3OY6@$HYqVyzU}t4e&~fTm}{e@(r3f?9OL0|xOHE?*?H9!DQNy{y?*!N z&Hk=dnF-(UU+oXc^gSX zgiwB}YZ1DbJ8eZt_^vmTYS#TWDfwoEm9!N>!k*8wlryC;NPopjO=X;}+pAgbea&*` zb^B$h&ubRu>DV335L1UQ3uN<22RHHIHHT5lkJnSB%9qzurOKbzH!zm?+cP@;p|mmw zu%|ZvViF?0wS)elfmG^F4pfQBG{(k=ToaFLqH#?uc97Tzir4@xDTQ7YR{n1B@s<(F zAdPsjtvP8dl>qh2yEV%VYL-jikLpt8+SFT+PGGFkj9VNi(K}1r(?#lpd3!lEKd$D{W~r7=}{ziRQp#Z^2OwUH4XQ`Xh@vgtyG zhVky9fa2$-w-;?N)wsjxtx|rI(OaebKBKqF9NTsd;(%!2sYS2tEjzirGob#Ct+^5P zeO*ql!^oxxwuNiAgHtX_-Od68*lj;4W&Q&C(g^>imbnzhua9HNyN%Cvk1IWJy3VRg ze<@RB3HwK*v%z+m&&0CoqgttbUwtGHkRDp|(caYMjd;nG>GQDY{ahDqesgG|Xo8I; zp9DW{b!m0i5aEb`qaV!19%m4i#3UKz(?n0ehM%+KN)vp&4w&p3^0szMXf#eSr;uyw zXCK~&KAeX>T!%iWThjKIBvd5}eHes3%sicNuLXuf#%F+7STjT)YlYF|O-a>|+&0_h zC)!2Yo>G1B1=YHtN`5twrVnzI=tecAYVtTMXzHCt4h!}MPd-j3aevw!$CG#@g^nir z?WSt=rSbdo>yLjaB?0!cT*}isrAzfPPU%wZj8nRi*<$%)Q%HK$*tleNbTRQ*Hd1_i zHU);Dl#^FeU@m(Vn5({i0_OtZYbm~zV~1A{HKJo;L=yjqB>oZUp+@Bg$G8=}Z$;;= z2&n8w+s+cQR^8sb97Tq2S~Vx+SdH{wjh#Jekbuc8lYlH4{AK)?_kWo+Bm<4?&&!R> zbjzih2&eRI5~SJx0MRJLuqH%*&?V%gDuo# z`}iboG4~3-T7PiHH=-)iLixu(PK0#9Es~P`1vpTEMd;{{f8=SIzI?`c=a4ImVMT%# zJeF2`3_k9UfBY5x$A?@p=G$@@3K`}kv=Je65zUm@w!dgfpBpd68_*HnyBkU0nxkXt%MxA?gNo+geDECkgW=ezB-9G@qOQr7!f4v7Osss z?-xPE?;L`+3OffRK9XPMo3ar9kqRnb7Ub93_9ZPb{eaVm)Hevfg0b##pnrHD`fwil za2@*aan)9wNUw%al`QmO5c)7%brdJ!6XA*FJ3$&JD-|5qUY#ddGQsStj`E65p=63T z2aQlms1hkuu9{Wbn!sxorY4I<)AwyZR@%gDp8*0!iaY45VkN`8>Csn%)fG4|vm#Bh z={gxz?cK!3YP^%v(o{%{UD>oVu-ckI-|dldDNN0HeA(p_(CjR1>KYd{>lnw3K?RH)YFHu}72ie9 z2Z>rv*eA#GQ5peE*5GR1s%TM-fJLLId1(7P)-axC>%^t1oUIX_s>W=c@^>{`=-8gE zA(MGIhRW$1al>j%-zk4r(}#{Fk<#o(>JaYs((`OK>SDkYcE%c^4%@+=J%zU_3bWJu z>LQ+&hgD=lih6DH=azPyCj~58jqr*vfe1Tn6kM^bll5NPiL3~0kP57bH0kZpe)r|u z)9$;IS30{C3adwvG}?6rP(8n`CiCNKUBqVz<6(RH=J3vb>vm?pb@Soz69y3h#`xuz zk%q}V7+P;@RmUG+v+fsBM?@0kcxD~J{d@#_G_h^2fz4u-3hWa7{xeLWn?(9X5hvDV zdmcj^f?VI|*a|T~ms|XgrSX!RR>lu`@pv>06@9$FgFephppWZC^nt6ZT^Q-^zCDt< zm%s(TieY^$8CG~`Y-KBr9YOE+gK#4kL;c-k~OTs4Hjvh{>t|CZS+^R z$8V#**(X7I=gyQ<;^c?m#VX@6)kT~QhRGm0ALhMyIJ~wmr0H?wLxZ{1{G#5OVYyn? z2=bI{>&!GP7OtLru}~Vo<$Bq{q7Iz}&;ifTZbA#fziO&hfl27@c8*Us%hnpx-c}ak z*iinR@Uv!Hgr>F20=8C{6-Zm7RkmyEHCeZ8Q$4o3`ld_Zri@3VM~EV0?Inv3)dPCs z`UL8JfJRitZTXrv$n=)ZYxpM=bTJ8i$U+~+p%3Sw4{pRp>7sZm39qH2cOO-Mp1=x| zzS$$DO5~v+Ma(-{--`1NRp(7dS(S4VZ={am%Y;GAm=Rl7GngUWxTeden#Z9PGYRW> z@+MY|HUwB7+|-C9>{!o%2x`VhKSbvqpOm-e^L!i&0P8k&6r3A6Jp%hyv!o@6&r$2- zbkAdX_UaMDQ}3St`$Ylc{igH*_?QNTF=)WA5uIWV$C0pt2p10%aRFlv%S zJL5ggwC0d`OXXB?GA=F+`e~PAXeH%LdR7~Oe_PYAhK85Ss zF!CiVpXiz52Yu zL}lUgDL;;t;^!>Qg7X2)rVF};BW(fLh|OLZ+GG=>;`jFdNdw+ zY&tQ?6)G7uuwa%7ya_H6BrEk4)vOyoPU4&(is^8OEwm!DFVT z%Y6f*(L=J8ZaW)~;qQP}PkjmDehBA7a#cv43dvC+`6(nfh2*6Wn-yfQeE9}6{XS+` zilIc}(eKM|5&R`nGoil~TZW$>ZBmM{XcIGYv9Fp>mZj8ZNxLS9LoN6xKRYWZjgIys zpG`gO6ux!})=r_fQ@HK;eZjPBy58haFkOO0*f7BFutULlG`XeDSJ))78t?~t&;~B= zguJoDQ*sO$#T-v8e}-SZ&Vw~AQ0I6yh2_7xNV4cGoxqy)SPUsx2HWb4!(Maqu1KIj zPwVTR1NED4$`8^mPXtG~kIU*>q!b(1mwxIvNh@b29^QmqOH|k=PS6TOaQFm(- zD$+YoT}%}>z803DZ;ZCQ+=@{s_1_T|qt(jU5>(JbZeHXoZWsBA669;Qe5gk#R5V7R zq5_4AAPN;03Kb>_6=f(?SSVC@P^hShLQwb{qd_l@6ndcm9*H3rH^w7HBrV3}kr!uV z@wxEE&pR7@4DX;739ivQj&hO4U>bOX&6s@sS7V)I<=&j!hrJm(7;bBK1`#bVh8v=q zQLG%(25HfcCxb4rE8X!5GAzJ{tU5W^@u`(-{l1~7SD~h@h^|(1c}e6Ox106%sjj$t z@KrH{#~!RzUr+pBg)fXnHwg+smlFLU_mVOs#wWPW_;}nOk3)JEqAyI#C0S2zkKV^t z=U3=k#Pp72*KTRt!(pFLh^i#gs*O^hh)vbB_)&P(F#v5?sP85_C z$uN{2=#uBac*>GsDD{UWJclN(P0{o{6_8XaD%q#0rDAC@T|d<7%mezP>9|adPu&JW zi6tA?AEf6Au#QP|5yLNnrRGj+Xy6#!?BJS)Mho!Y)V39|d}ZjbM0V**ktt+6j8hTb zU8uCaWLZWkQ&>84UfR#-Hrq7q4U>pjTM2i@ll((ENCwf$SA$gyAe{842!8zOIgB#9=8R zrGox}FQG9^0T~8eHqFW@;`E03dG{juIGBybD`xXcZUAA4I<1Jcrsu~IPav|8p(dWCQ6}p5qN{+Dp($Q^HZZ zEFb+X(HS4azHb1r61qbmJGN;Lf$RG_2G`sK)iVK3Jm(;k$G1%=C$~u`DPB(l5*cD3 zZbUfmFa2ufG^m9FwImLq;uKoVmXsJ)y|F?6126v=oGg3`hyM)E2|Z%DdvCF#YfS8F3IK8w&)(ax$ZhekJK zXWTXns&K11u-gT#30Y)PbRA%5VvEv@-Rj(m#&eq}>Cw@a&95vgb$FFf(43Wg{*t0Y zU9T1@cdJmP_2=SjDQ?$iP4Tg$+DS5s(+o*l?|PaPn71v>GN6M?<*mRxaYt5(!uZ&% zm!D6?=T_E7cgU;RUZ~tc*Sm_<6dfAO;l#rbPRw*XxQiw}O6fFK__#~Av0^pAWa3lC zXetX&P0HUa-mhReSwO_*(z$?%0k=6Siba^O%VO>>i_juhZJ|2br_R=?vu#RvZ`sX) zc2xM+T{>6Swq2l7)J}UIj3gkf5&?t6Ag32y)Y96P2$or|63bXEOHqXFRo3Ln{fklo zoIf=T4dxKe@%zu%cJxiu{)K@>cgLmreK(j!z*ONl-?|12*2W^$^t?f-rRQs+XT_?k zt~aVS)7#T`5fxT%rm=4R6hj4(b}JgilS|Ul!@~A}ZvdWRoEPad{oqJi>DdY`=H@Ta zbKq${e&=OtxT_(pJ1#k!V~fzsLm19Qlh16QMSQ4{XRMItD`C~Mir7e@BaU3p=*Wte zzUnQp5wg+VtpXx6+VLedZRy7&HgJgmDtWvFXD;`Gi@I0TS(~FUP^5Ihx9m@7&4OXhYPLsGSmOo^C*)Q6wgiz5}jLEFUW3q*) zRkF_M$y>aSvRjeG#oie@(M#GRfj0{Gi{xNecS{ zRcXZgo&&dwiZi@@hIqOG9C8vd5hu#ekWcQBAcA5I@Xh^r*q;sKX)?gpMB~G2Sb0yA7}Z5x&!%r!)Zf_2a!Hbc{Xbe zxs}-@BRK$^t}(wr6}slbs=#08(+h%2r~zt&uSFDNVjTp|aG3WIXqJEnbH#Ox@+=}b z4jXt7@Y-XllQ|^h62Y~+qF1gakd)WsQndu0Upyx1hp~ZzZF|!>plh(3zv{xWH2{JI zTT5MXmX@pwrlI%c$)<>T91Xen8~yjc(U(GIO^YtaN>OYTzw^%g@fCI6@$`6Sw*$=M zi+G^2L?~B1K$UXcbc7)Vjpbg|xy{hd2eEedBI#e^{4^KAI2$l2k~T~XsHCy9T)>^^ z>EQd=NS85wvZP`WY=ONjjbl~dMn}G>l0KNMvBI!Vp_U`G^3`Y6HM~+K4E!;rYhMl| zH6DZcfbqcZCgZ`NxeFbSAwMx`smXZEeYb$|w2jfUn~Y_F12IKEZO8kgX>bY4;4E$p2kQUgMVqqHbFRDYv3uyXqVgWwj*is)C!MynxVNP| zteS)2=OXcK4S5%7|a*lh)1T?UJAiAW3Z7M+-(V`rROs>)*VXTWt!@}l6XP9DT zRvhg%`>RU0ndg4Oyu3@8dvP@PTurSuK_e}_&sN}2WilM-9FfP!A(X^eHpmKv*(ttK zCPNiqofsZ#oRg1nqCzg;1TPHA&Tv35RrKlh87n_p`j{+<;djYtG0axr(d;4hc`pCR z1>@yy`_6eVegC*>WD6zl0gq;n7s@SWytl-|+2b`8={FefqIo=fpzQ?=)58I3_nZO@ zpiZ9fsZoXJm1t5^3r;y#E#9TdP-=3m7R2rq(`lM_)wRbErNgHNMYAs2)wKrK%C~~g zEt`z*y_MI$tii*UE=$p*h~t4}MprF1w&{f4QBPrgthLx`&Veb9FZrpiA8oe6nd8Xf zwap={-_M9sj?BAb0WTxLAp$QjNLWvBz`r_rg@EY3*xBoz?7uqLIemBRO=mR6GRdXl za)-89rFCj8qzoD;p{eA7m)rIvB#bL9on4gp4^Z7r?0z5KkS~g+ue7^`_e`>o21=z zG|nf}72URkud{fRw4}vrjVP`jD630uQ^wtsl@B>)YZkS)^_NiA{;gfCsJ@B0#6y%1 z@}!8e9LURTjN^`QR?(l@Z9%bIV2HSDxFQxHa1qo;;%VRPzhG=Fe*44c=gyvC+5^;D zAEkKAt{2m|H%!(yH`<#Iib?+gV(X}v3I_KEAjRvRz1b9oJw;pWgM1Q=a-b{Mi9U8Tbz_fa~V z4Ka-S6k9_2d-(1&+Bx_s0wRCBb8!08Hu*4NT>S(cXvkM)G#;kt+!RkHaW=ii8NBTr z@4kleJ1_R%?4SNb1D`}M_fHQxCnwR%!{cZtI@&ot-QRupX6HCMdUt$uc+%N`!zD?| zVU0}*aG%k_0Z0eQG){+w0KreN*4+Jy4)RITPtp%C#5n2$9@bt@Y%9jA{LFF7!t8Aj zvDsj03+x^q{j`7Z3g)nXhKF7&x|*a@^!BMjgI2Vk^*374<3C5I2>>&Rj)rkRiPoc& z8Mg57;btp(kr&e(H6Uxz+noqVUAw*Bez^HGKhj4TgyVoi1SbsQJP_+kP~wBjML za0~}Qw;vCOy|{lF(XTVuDYOu4^b-||7B_1%uBvh4HE+#*hfQv~iJPXdP5Y7H!&Rz6 zm|>O*#RsU$jJxNPd^YaFJko(ci9z&?g>PDajvMs!%}Mv@c>nJ^ zr=6Aa$#??>sQh`b@Uuu1>+BwN_l~+J@GnT3$8Dci_5NO0^q;{|FouGB38Q2PbhNZp z5IgI&3I*%83NmQDR-vFzf3e=ym&O+q*jXwe#nf6aTJYXoS~IL1<*mtu3b$sML&{r|3xtnXo#m;^Wn_zxkh`WuMOfHr803>j zhS=MC@~C@D#6+W2hQFppm?hGTFGEEr!oif@Xu>n%6?2NEpCHKcDlqXbu+Rm~ng?hu zFexAUbWC%Y<_xML8?i|NjD$*pyPpC$c%&(+vBJT#s(E=Dew@?M_-D^CD4j=vYmnRa z@15h5{lkOq+nxUdjN9{Q%b03^I_VB3y>kT<@rFltKs8XP@QM|1hrl_a>ra$pCO=zo zp{{2@#0oW%Fj{MqX6Y2FuIkRJ5_NnHVhN5mwlCR-u>&Lt*2#8aj zZ6!}kblmQ2uRM(02ykKkKBTy0PUC|3Mao?D6Kl?FV0f@XHkgb zgFx_U3Yy>(f?4os5+*FF+{VUJ8}EY8{0R9wg}w)Eb$+-m@-7B+3jtdrkOg}5@nofs zAQoE1nzYpW+zio!Nd9@1>aCKwDSnmw7K5K1@smcwE~ zhzsFT_HEeUrP|;J%QkL)=_QFysFekG#xYG2iTjh_w&gF zL}rFL7l|4DT*uz9UdRh@xwyWYHe8KiFLf|R7$bTb-Py2xcf434{xXty;eRV{)daFc z2}dG;b?Od^!O(lTThSip){S$yTSCo<^T^a9JjA1&O^SXqA5jVD?#nkjuY@)<`mgo+ z-HSK-yW56pkd(j(!l$}6N9wpu zEa=P)+nv=A1?*(y(Mmi_rpbyzj(Nu}9(sK_Dqkn=xRZNp?9#EMsx!T!P zVG0hKfqi~;>O>-!?7)F!9w){jbUU=VzM)|>PNRcu=T*lLFh7(1+a&vq7K_1P`C!#q zGybJx8GkAdla$KFcdcnM4hw4J#P$cP757Ta-SxHScw;%|tzi4ft~g?jzJg!hex;q9pYdFq*$S_A|$&nu~~ zMK7Hq|5{M-L4^(xAk-CA&&Krc+%4lch9@InT+4?LKWtgQ#&Y4Psw9CT4K* zjwgualYmF&07$RLoe9sJK{CpxiS0puz2KLl;FrHy z$0rYPQZKs6v8i&^d$9SsR4))Qq9cb7)93kR1Afd7^MjA4zUtSiziQN;7oN2wd+~7G@Kn&2!37H2!qM_F=eOA= zT=r`HR#zKY{%H#KahZHH&*kMK_}|~)e|y@AY>(1&nAU(MgJ|W5IH$njcSoagE%naW zkiwvw{K_&P8u71!6IlF^8jq$UMsphga$d=9OSmKjD1%dKJhMG9v%UKO=OZziqx&$L zzlqWO?LLfVPXcG}UO;D0f@kkuz~^rgK7YFn_*i~6^s>2&m@^UIK~W;WEpkScOfBuozn6EJLn zxG?8*_j#JQwm>Q+!l&yu<0^HSh60m{-XmKapT<0zAltrXo8!0+$VBSR+JnYA4YWl@ zyY{gU%Syh;K{ZYdJIegN)72NhYBVBouSVG?j~_q$*7Dm65ZemdgLuMW!G6`(%pXuo z-WA8Y@sq?h8?;+imWs^m(9k5%c2)ZaTOJF5r`(aJ+}}Lq z{^lvy@s#UqZGU0E6ngV^P}O~~71oc3YaNAa{ViPUZ{b>Ja ztx)Uun5;wv5O9ZUUd7$rw@2J!HHXd{u*0XfZ~Lg5oPl5W(MAPB+pl40&&S(_;8hMY z58U`%w|sNmnq#h8IM*%zT(|DQT=mUDnhiJ`;NKNmAf%1=U?`n7gVwDLC7^?9jPgzK zCOBj4S}M7=NQ?97mw^qcBL~&F%>@amV1smxTl4M(VFShiO>OPpKUo7l2xq$WnW!}# z%B>T%`a>aXJ-Qb|`5SGV&!ql;htxM6)R7$2(ft|J-{heFcDIM3@$0@=NWw9n19GTw z&z2O&xEpcz(U0w#m2gMm4&;>_d5E>_SE+B%g>eV!tleOhpxNW5qMH}jLgWA2>W2O5 zA08Fha%eK%`gbFu-gKTn-Ef{i{YK{be{VR?|9eOCtYFRUwi|;cbaO2Ti-A3H|K!U6 zP!0qJh!U_gpvnyrWjL7utq}9s0PnM%5Az;nl(rHA3SDo>IQ`M~IEemeRe&kq%y8vX ze)3N~l_@t+g==}$v)p(UuH{wFasyhpmad*9AUS^i{Fd7&zD)4g%F}Gh->sNdE@?}S z*3P*WU&3E6Lrp|$WBpD5@1!s;1@H)d%u|HpwsDQE;9mFqMhiOLtE4HoJ&Puu_l{wl z&6R=`i`zFav2n`?+j;b|`|e=(@a@rY=j5cb=b?0zdd|MBQ@A%$3+qOz9v}4hm^yp$ z?&ZtQargA_uzT`$$D9^!wUg81{exG`BwOgd5T%eRg_aj$8r1F;=n zrVs(YeCFx&hHdlrg&wd~#erM10&-;OK!%6lL0Ii1G&hQ_x+K18nS+}}R9zBZD_aOf zQC$*WmnvwvNxta%XzhohpdvLtCmzH#*#DZ!^{2zldsdniGP7(T= zgg#`U5Ae^N7o0q|nGXC{fakfq6TYHzU>W!%yc7)WJ5i!Yec~)#9{R~->I+UX>6<;q zg8~1O_r_g&u)b>z_k`)h9nI-2?P%7D-xMCCjKq53(aBcVn3BXCjj)iHg&6^++t&am z>bUc-9B%2H-BWO7fwv~`sDqB}6Wg{swr$(CZQHhOJL%YV$M)p@@61%)hk2RD{czrP z)jqYpwSHf{DX>hm7)b0RwGDyB;>^n_#M$Nnw8`qg2`RXtBMG)g8oTQNcD^)%GxbBh zgR*Ok%{~ZMsO)o>P5sDh&;gEpGPRIDKf7({_Uhnt$CN}z6K?&usdEjjHmdcSQn$~F zE4^;*^Q$!Jr3W{%kh-|C9ur%19JeUl8m#9$q!awpKM4bY8Pd=v*FsqR2I=t}X z133s~cF*J|N@e$cCgPZEbIel@oo;q#3D3-2z&!S_Oms?W_eKNG??o&7wdhg9xE6zy zmcvwxPln$M@~hfIj|m6KuXT{e?Ey$&pHciXb90Fp`hYes*h0Jn$nv!Nw%^F)DO zp^26Lr<$6@Ob?RLgj4!A`2@JoRY5AoccjmztZ7vafNSV`C{mGxD`MNPk}hlQZAb;N z%)`DN;P#(HH@+Of{Wk+2Z^_B>ZXu``Ni(Cf2qRyss3~!;KALSVCl^mCB`MVLp4hIT zwEOZO@ud=Qp^k208X2_=&qxJjg}DvAUo>w8z$QrhL4^aKgo}1)mrJm~4jBT~iB%!% zrHtG8tda<5wPv^&RKI;~R-+*1qeT8q(m2poj{$PJLAwWQXC1cn{s~(nysz$?WPMc! zv_&-c5~%tjBY2jJpOQa`D^~<_g|yh`-3zppzEylq@Fi9ts?>(n=XkNRr5(e8rRaxwUulH>o1>XlF+fn!PDb5bdFY9C47NZV9NVyD;&JZh4vHOdP*TYk+YB zcvA4t-j-T4JY()u#`|ZdmJZzJj7cr83i}rB1deQY#b;r)-a12g7VK=}~heY*GXW-I|$`ID#zXjdmKDG2zN`kay7+!lp`&H6r%jYH`d9 z)uRD_b|`AFEqP9ss31=9xBrG~^*4o;xC8oMLBu$-1PX6-;cIHfrs&gN+*s~RQtF{^ zZ<7c7PYAaElk!b6A-tOi{sLNtGz#{c`%q*x=yY6Spna$3yVfDbgJ_(08@4hSH#9^K zn~zYV;vA&TgJ0bX&^;0Oq^^*`%$|H}K9Q1q{H&%;ULV5|U#Tb9Dj!&jS;jnPF2_r2 zP!U%_!Ij5o7~|t%7BUitp(UfMg%vB6NM3U0(YixShN7@q^d(F58U{#9{zT}ONl|Zp zATxcvh{l>0>>$?xZpJg@cHI2l-~!1vf_!lNSW2V0B;YCl;ys}u&x!U}QV|VNscCSp zcJJGrkw=I#cLk~ZCt;XgG2$g-_0K9M8B!rIx~UAQCP9s!$MJu5+uD(ek`&HorHza@H9d@{LUnZ@Z|Zod=BI;BhlTpV zKQi@@iVl{>?qJz|Uuz!Rbz_md_EbJ$m{$ z%eR$jKm?agT09}=&$!@|K(&BQH#hwA)AS+P$Jd56|C_I1ZJlG3n=#a7_VN`joBUPe%eEXg6l_0Ezo*F2oa2HIRg&ylGbzah)TXVk(txA5cu2l-#VfK1{g zVdTZ^!K6`^MggL6by+6cD(qjh>f0jq=JOTQ0T6IuZ^%O6Spv*xaEWiz{{ECbc5HP7 z?DAf}oEuq^v!m3IO@!()e}|96Og-Cg<&(oE&pQv%gG6(=fv9(v*dB`rNGhS4wW$6M zPpp7z=S+{yZA$CkJu4O#CtGI(mSs9M@{&QqYb=1AlSC&E28{|br@sL~%Ed4j%q$d| zmY7O$OS!sY({$AczJ97yOKrTAk`?OhG*qmF3KJm=iVq!N@hPz^^f^ZbUMSOrz$&7^ zi_Uki#h$6+$H0u^9++=nFy70_?MR+F3o=lK5?0PmQ{`7Q*#)0#D_o&5Cp7}WJT>9g z2u@qLd4WwlA=*}}`!<4T!s`tYLrKQ{zl^{$NGquo68Rk_e3#f~5 zs)AIL%Tm%wSK6zAsIf`NMwP8pM5n#H)e_PJ3rZk%=y866mEr%k`*;S>5U^njlxmOx zG`Hy*^^Cpwq@b-fhj*ln$;ROxY`^a={iUI%ga4s%LTmyXBkorZjgMZ zuC@uJrihdp1!uxY*`;_$N|jNj_z5EmZbY2Ht^del@0g@sHw%fdIl`L!jxe802i-DY z>R9Gq5dK6HP9*p!pxhpM2sw$!7x~IG>gsuU*_$D)hK?;s!ErB6R{8PH+(9`*Y;J}u zgmCH+d1on1&0{%GHHwQk02yH|pP-isl6t88`r^#hLC_L}mBaR;DZnV~A+nR>7tB+y zLYP8DXPjVS9Fnc`hX9_WU*MVPhf1M0`w=}qi2RGX04D&F8!&9MmY~3w^zcE!eeVU1 zmtRkhzO24SNcFZrV9+fooah{&T3&6#=_1zHK>cLAqSm!F9hKH4s549%lG;*@HzKny#ca3NG=-WSB|Pz48u4=vKp za-3^@1(p^x(Mg-D6hG+uGXbC^(ApRy;(v3O^|XZF;F<8*`VqOs$MEwrhD!5AoXdV!Nz&I7*d_!5igX0XGUch(hzhQ7{mlD$1MH6;n17mL16(hS-7B4$B$4^vbZHs03?R(&oGyeNmjv^cN-Q zSf&QgR8DrxM+OL2%x7crvyae0C($vDC#lh<6{##qkaJasJSC6d*sk>*9eFlMs!?aY zK95VYN)#97x#P1ukW*8jhzM@c8zN{&TiRfX?ryqd>_*%KX4Zx~P)jo<=v$xge|IeE zq-bnMJaJTxlahQzd=V{5|Il!6B9`0uCYX>$t;j2>h+rt(%eH|16`Ow|^FEg&Xy`Ah zv&U;|2)*&VzTdpiGj(^KSe6233HF)O0+5C!qoZIsh-9mmrj{vlu2ph|K$~AR#Bd~g| z2NsO#0BIV-!@+ZcuRBCjXUUz}_38a1%>y?(XTvQR`gpYeCnqn+9>F@LUW?{tH_d|G5AYMLY>9ci$6R3pFUsS zKC@TbE8Og&l1`aJG4pYQ5Xm3uDuDya)K4|W4Ao{EQM3N;3M0@qZ{#D}AdkrqQ?NTk zt0b%W4dV{7F%|qbEs#lA$&XXxZ|PZws@_>8&qv#FH$>4-Guac`QnmV3mBc|G3A{*n zy@rfxzAW_TxJ9(0t0G&!ZAgKyK+MR@P0*V+{%cgGXlLl`{xz&znoD^(_NE@GFL{SZ z`};HAd9&)|2g%(xMrs{Hc;b;qX&mVl^XEA3yzaqLX)l%I<9tUU5+-^u{;*<{ z;MZ}+f!)OWh`v~tPPOP`AIySnv_Hp@_V5G`&wW{(J$igHSXHnCr*b(0!^A8p@?rAb zL{=)0jTd|!+*W^S5CF_M#m9Omk6bDt4?>F7r<=_un@a7JCFoe)b2!_R!(RP0u5cZ4 z+v=isbforqq}H*K*jc~FK%3dv(bn+1m2vuwcso5IwJ#K$Y(n{=;_C8~Yu>Z*F)*f` z!^)zDnd$wv*IF8+>nRChZBsWZL*m`Y5u%29qqTwR zQS_u^{icD+q=t$)g{1+BW8%DzSV7|hkq%t{#!pvuy;jhufBC=cEHH2&-HFnhtKHDR zK|FX6U~s{c(%<>_2VZ9wSM%_lWS1__Tem%%?~PD5*F+Pq#hLs!ERBR=TkRr4{O}B` z#gqIa)A};te=aW>H3-ffo|+iXcaUtRzYaZMsK4=LBgiNHYP z@!`V&tNKB;uzGr$uhzDIU!?oOj0_uSQ0EWXXC$>a#5nOAFKt6_11yt7Xe##W;YWLG zd}u{H6pa4=0Thq@u3fM$VG<`nUexhX`G(ZL319I~3}CQLgQ(4v4ow#--4d)sS6*St zG{L!0G9Y?N*)j))N>8ue@pJ$DRQc_(Xsi6uwaS7B08xvOC)mCFFH(_|;`hr_#A=GZ z(~#A@?O&e+;3F{hxaOWVAjYl#sVY*uPrD=)onplD!u|S)X<=P2VA?i*U_tYi{=5`6p!Mi4DZEo#YHPz?|1Tmnbeu{Y%VAtW=+o^MV|eh?2*)b*m4_EQu`u~WgdEi$HTDj(rRXVqHZ22}nT2Q;W*7RE`cc-TRJDc8> z;`vWD-ITgRmMETLtHr&dgSr5WgYqI%ITaHFL7u4xJp=I+`;0t~y%S1!txKx-O{NAi zq`TAlUqLj)uymGF%=b3OQ!|r)HGi>toLyClJ`ZfcbB8P~O12wBW;Z(vROnFKVP?~wu zwN4J^G)kE;+ioYq6Rq89g`k%rHDPV=zw-8L;ryie!LG5ZU5FsezpUU)7{-9@bp+5-_EtNZ1owOTGqM$PxC{bD;{@cWJRDQ+q{hRD8~5`9yAdt-oSy6T`kE zYfUkGb_=Lrd$^)!+U&)(Ys%PZjVELy3HG zXk0vxxdCTgws7HM)Vk8*jIZ2`x^YrG{2W|vQM@~_>fyP4{dQAyA{k-Vy-~<|YVc*4 zq;)TA(`_vV60~Bmv5P)up!~%gYeEbmPRWae)TY+o=KdFuM)E#LJY#Yor=M@p*Fbg5 ztRGQL9{4>F8|9<7XU-|HD`hMlz7enH9t@hu;>U1n3`(OO`BvoBs}R!%h1`>06sXsy zqXId$)o8VZm4tx^3!ZWCrP9@u;lh|J0v0gtNoa#H+Kf4Vh<_u2?Dlusz|AQ@I8CZfv#JE4}YSC-}?+*lD>?UOgex>YHYM zKap;OxubU+3>c+p6Z*HH_V&F{TAbS!TFIVJT=SX`lowy_wKE)?oGSppFRvC!bb;+N z5HTyJkYbk%y;x}7zYzoL!QAaNR5vg&iGUQ_>t( zc7ANIOV6oDJILw{?QQOSW7yZ0%FYYc`i>Y;km&TREC3VTM4hb5k||_#jh=T@)mB!= zIhHdUZxKB$gA?WEzJG80t1>W~O(|gM{hH|@GTj>dsebM)Z_^*;>9LbYM8Rq(Fqu!h z#CG3cJzoELOt`XW%cPUV&e$HL{ZZo#czaZ0$o%yH14# zztKsE08cFIZG&yxTv?BbG*^aNBx=y)m%xKA$lUFA|K9D!l9{?82h6BG$PiPhV#_UP zws_sx>_(3N%_D=y11!d*b4<6+Ju-vYZ+3iT(wpz7Y3(%)?NB0nu_yrKEDA;{912>_ zX-66>DVs1uUG=Z#5ocBep=Ry<_NVs{aF(m*gUV~ z%*k_LHQKt1YZNbzM4%q z#YwxPus>lKD;4(Iir57kR6jxy+7+$By&teg)Gj(ff3fv+yg5`FnrRNx_9OVewrD!D;h<=HzU%O z9=j0W4NsnmZyyGs6!gdCjp}t(c0_R|UIg)Eu#R(zBg4lGc#`u|FN7YAnw`IyYSnIQ zFe;XGiMsq|#54_!ecQeL{%ZQHMY?@O+VtvsgM)X7z3|#aR`o^crN_5@WjK~<^4PLF zAgw`r(4$s0zOMe_6c23vQ1llB3-a^~LS^V}kb$jP+h{aanh_AHQDhqZfdE+y%_quCs=OPE^>T8apxfUYd3~DTc9RHj0RVjL+ zqngh*1UXdk)#&@%<)6yysiZfp4~rPR|Al~)@J8a0M2|_Exqx6Q85~HQA`O9FVHG7P zd7J^0Tx^S;}NoN1;Sq{4-u`eAgr%-H&dlV$J{J z(I^+$U(m2qc;M|`wRkllqHMk5rjm4!u~j$3ukN&={ZHDHvA05-7VBn@2;fZ}^X0K2 z2~y^U3e~5>ZrvD&uwgX80i*8!69-#^(iU*M!@=_|z+*4K*X34+SIRP-WG+;1#hhLP zZ&y%TD#iSxqHO}5`%CPmkG-R+vbD7fqEzk4~B ze)#!i#pq8newHDTzH4c=pe82_ik;YflJo087q(=L+)ug>e4Wpq=8y!o$1+)_l7uk8 zV!^y*+%OLOg7UET(S&$hHk#t|S)CaIu_;v9Rx3hfOHU6jxe6z8$?ml0q3C;>jljJy8Jk(LvcaezH2a7xuXNC`9x(~xC211G5@Zn4OMvw^WM9- z0o4f#ZH9JfM?(&cT5-|w3wjQn(q(+JG`%?Hd6){+AwLJX1c=ODh<<<7k4ytoSLrFQ zL#K;@GS)$@)ob9OnG%Ng!v=NbkgAvs}`}CKewkdqk&VohHAuGmD$zNhf`BCfQ zdohtdu-U!2%va?c&_fEE?4+n{hKgutjZ=*vCa+C$3$hop^mi5wy*FgP{tQ|g1(2L| zKnHXY!*N9zozhG8OTUUS4mx)hE^TNN1LV8RH|zqJ)bb64g1vf_D#FMe4SH^h+c zJ|qwwOec0;AI`Qq;G1zIV0x2r_f0Hh7N>|2Em_KAiBiOGF$gPeY7Bww!-E$sFimv$ zTo>RbD&>3B3$Do!ae4Y{)QHs>a6PqYGd@F6b}Y=OL4U$^1NZ)~0ybq?KtZGi_?lSQ zpq{1P)lGpB)Q3noLNrw=_(vsuil?xlisvT>o7uP20}HNKQdGwpf&A}cgl~u9hOY)S zU{NU`TBLP7sx?9c-Fjot7db|YdZ#)x!x5l7L<3d|F@kD7%Z$Mw)cUq3uq83=7`~{l zL#g63u+R71qwVPDzG}Vd!%}#^le!Y5fz3vLbW7A(`RlUZwUPE6o#%L=z&AATZ?wR3 zr1eG*j-J|2CR3Lr`kT%kIRqEBH;zlh|B$QHktG6O3o_-g@ZzyryGBRdQ2)4=ui35a zroF&3=yVNQ(De)CRFmN?7({5kyLLiG!FMh>tHpfvCIll`jT84E=@{k)v2dh(I*zC! z!5V7tf+)t8V8CSLHoZ`nW)~ylr?;ykytq4)5@|8IxYiMQcQ#6|rn< zNaugo6%y{b0(Hg89UDUyk775KD>~4w{^=U1L{r_|@Y`Svl!i^G`&f1*jp9{#^ zs%?i#1c{->cIDICp0!R3+eFnluWtu#kgSqU=CW!X2~M59ti^^MV8!-@P$J$FXQN`| zLCv9 z2e*(a6!hLz4_{0b0}fDkW@mU44~^+A8j@ejE(cjRadnB#2HP{&t=%9O;N0o;Mv8?U zp^k?P(L5L1$IQ#F30ow!!+U>!Gcp}ZH^Ke}VQB$3QjFVw8}>jtBdB?pZg$mZ`lYO+ z^EE(di1nBk?pEn-m}^nlF&NB6{8vp(Ah42wpENvYttn-#T6&+31jEW`L(sVQyh!4# zn8GzMn5NX&oCQHk;xPqb|2W$wLQwP=x8r_fw7=Roa@hMy5b4(w(D%8-)4IIv5iHrs z&xdKAsTwvRrn!PjSb8BtoHd=RwK34XZ~rERc381iILgvRDx#Fi?TTjl-rggNq(Zj; zMVUpUXQ<_vZ6(R$@2cWo*x81zbW?bn??-13=%H)sqg3$3dAA9YX@fM`rN?dksPSD! zfX<-k``Q&Kg*9d1aN0qWsEzWGR+)Itl*U7a4vR3DqBsTKF7B8T<$KNk1tAux z8v~Y+;!ELNFu6;+jHWFf@#2az1k$WF=T(I9(rACj0!(JCB)Ygdc}-x2Ws^cP5TO^Z z(6y7H<9xzshnB?|g~Wq^ycg>cFi4%kWQv`SC;tn;uEIau1&xWY_95M4!iW}}vL zvZ?pM`I%cn?jQjCRb5B08yAbf3u_HAPM9f*7D2xfF$qumow5OsIK$9|HKWh!dmC+s~a%FME8}!V**oA*7{j0=p2KquC|Q=LiymOO1d$ z$H^(g%IdF7skIMIdX z`4<9OI)6`)u%$Lz3#~E-N+_m|G1>eqiu}y?Fm$wTvwWJe)qE`{AUTa*zw;29r8THm z4ZQWKS~)w#)O2PW_h9H=8%KZ!(yA-jxVR*zs9-a&YkvX#kS@Rryt_(i1g$sIPv*>N zhlW1td1>b!V4xFsc5x{eCpCNPygI>%&+4lYRCRx97-PpNc^o0yZFodcaO`Em4-8yc z0eU6lN9B8%6t{V`3@Ry`*8T_;u|YOMW#K`(JUOeIxj8uJva!y^T64`C0({jXP$Pd+ zSm;ys+8R%Frt%u-bxsdBdhT}`8__3MeR2Gs99*7Z#BjJK$(Lbl130iJE2B24__5&9 zd^ET%_h07Oew&xy`lvMtQ$ZZQA;?sP`fh)eC0&0MEo4%T+?o+9eeEki<0QavbJgZ?1Y%K;$b zm7WWqJY+HnBi*!MO)SjmCEJW1^N{@1o+4jBvn%~Dr%=KCV&_v{;)(k$D9AvK2HGJC zUdLBs4g`hfg}6;!`O|};U>i;iD6$k;Iv36>y2Yj45}9T?e%j;e4_QB7m)!65q=od@ zdDFOs4hDb@K%gPa#tChH&%(g4foJV;H0Yy^-B1t#k63AmdDw&H0wLOI-k?5R&`gPH z3MCa})pxLgOnv@cu}o%v_x$S){gh*{fZrGF9VTu)q_0;%s~<^N1KCc11_-Xw|HJr` zO_L585E{hZ`R6ceF6wE(KDGAmoMm5lDF+`A)e_?3SHI9q+|&>3RPmuJ8wKi~Vz}$1G!OW}1V6MtQ^BXaRc^FD42&lkB;P*@2zo$BscK=s3H8)*urY+ez zbAAC?FiO9Fx4)Jb^SNO*#~Q2|IEY}*3)&_>6&Isz*f#eR53I$nJGRpCSGH}#Fv%mQ zKIalgMW`CbARVA6nwOLt5*&+=#MOT4$}p8l zT`apRAp*srfvvk|z3`W?a=9BKq{mP?(n~l>CfpVkRgGZ{;8v;N%U+V0O-f6iN`0nu{3P0yKjT6#z!0X;Z!2Fyp~p zJ5QZCyyG<>@2v*XfUd^XP_a$6cbOGC z%}eHmo@+20GE@l<=|;AeLWZ=1XAf~d>V5PM2*ShibdR9{B4R1c=D%hg)hirw&eHSC zNDA{cT)Om3CcA7P^mX$amYf`|Uf__Cn%Q|TN+YcG=VHRjow+fFld|O_R(Rj*WuPd} z{3L%7CjJ)lZWD)~w6RdGii9vi9t`pnm0PH)1@B?YYMS+^ly0-?Sx!rv*9c?8dImlc z**qT-QJnU3b4SRn+e18d7x;pH$A$T*tgl-b9pKt-^+g4l0GcIGps6lVoXQKBPaM*9 zv1;uIjl@s}^`IG3Q;VIeqN!bl`1Td(Gq>RXV>wXnjubDOF1AY)BI zD$#(VfPcGHBdjIuD0q_UY9&$S6&6fHRbTT|b`)0atd3{^(l;PH1ma00Z_Z3CqmpEb zQ=Pw(VFU^uG)Zh)>{`yJ)UiwfW>IIsaVltaP4oj(4~Jld(XcqpDlW8EGL1CP7rdwk z;(jpXMI1tIE{e*^tL;aZ`Gfd$*(4&q#GIniODw&TEM=9JlNtpm#f*&jO?B9jLXknu zb*pI10{)sBN)xxUDBXbi8grk}1G;cs8X&=&pM1+v9Y+4IB-LE;8YNaTLd^0uxWM=q z^v#&a@vVINEZeYybU*g7LG=sNM93ISlSU;yeqNB&dQq6ak-b!7qZea=UizxWrcf

O|4lTCb)w;0Y{Cmg+g`+oX$pS}8f|yIt8v>l{d8Ng(2H?!o6- z_zFn`jpc)sZW_3hi#04{D_SMm`D?Tr2xtxcaO_rs6I|UIUM^F!_S%J4U-Vl58xnQ; z+8dsK=MMmV4t!>VTJE84npS;i$sSb0STfSTNdl~M5o@!m(kxI#z>uw8ZZmqqDrb!) zw+&TetrhuRSZUeBf;M}(&2?Wm7ouEs^~vN#{6(~3);Mz-65@k!C>4z-{M9s z8-{fS3dh4lUC}DAnAAbwzzpXqx`tL{q335U_KB9CTjtC;Q=X?r{xemEp%GLgHDAwc z?)mahewHoU-hQflBlK*=X6$CX@yIN+w0uOtY%<~`pn#aF7gp(Mg8nDAd5WByDWiy= zzC!)I@j$uqh$qbPXem>GgXIi85mP3(fjC`$6$i>-FK~wSN3!w>YtJCBjpSF$$Zupa zKu4BLa>3AncHRt#J;InH|M=rJ5q?=eIl*TN_~5b*`P(%m19inUCDVD_$14lwl#u_s zf!Pg{GPXw;Zt>O)_@I70n2kqOLL59zu=F{^E3>;qKgnvz%zUJUNN3gtVG^Nmhs-a{ zLF~!yLl~CdtJMhXJQHZ6BZQ!sW_qcklw7RoLLMEsoED!Dxt=-d#{*)|WOs4?8AX-L z>Y=mJ>ArZXTQ?u}=eq=j9TkoT7wLd2m`vdNkVV;_Z!|5_rB<#x6=#0s>k0pd}|JOzP3DG4;?2q`s&E6ZJ+KX>*k+|^E=4l@$15Zx~oc_&Er zwxO6%z2pnPkR5!0>s%K*&2aS5?Cfr|f4`Wo7raFyGSFQzq|;E7Y~BffH*%RPc7;Gy zD}Y!#)%}K+eNWe91)?o zbG>M^0u>|Rvjz_B>?NqfqqKagbuIf*lU8`y3eXcjD)ja-(}xCCdYuFXEizDMw0@Bc z#lND(4B+jq?`uSckZTe&t}(vh^V5XU9|P}%xlC1Zk1*w+qW^5aE4u36q7gK%|CWo6 z4@r7WDE-y126i637nidy&C!sL%!%)CsEVmATZH3R8MCkM>q1zcAABSn`?NEvE$C{q zmlVVlC?vnNk)J*IWt@+p&BN3fu^(aPfvts+3D_jDLKDwCrPKaXJWXB=cTZa>;6Y0~Zaim7;dm!w? ztujK}J9%pJI}1IHq8+012Aogd8Cor2;J-yIjF757B2p-Ec)K%=-tzles9PEwhQNnK z-fYU2l!nE8s|Qo4G8XAt#GmX_4pJiRLZd=x^&&Qd_racyJd{dz00Eo4p}C%flVl3Z z4Gaxl;F=ojGCxiCVYd(?mTsSaY|p#}Z)Ctr5o)qOh#lMAZ=a8iMGN5Yu?8bE6Xjxg z>DyJ6F^{>|`6$QV#k;?z&&p*~+Zt+YhxZJozd8Ac>Sw88FzCZK+x;wV`aRXdd0qE; zQH|aEcsPlLC7*^RM75*H#HVN}7o_qrrxmf(wG3l1*A2ZS`#G2cE}+4LlsI409@IY) za${X&bX|9@J_g77ro~?0G41dJYeL@FD;Rjnl#8G@)XG=gFmcj#_)EWi47BXa1Fo4v zm~^qk6dN{}4{IBberi7;*h!;GvYzC>B_FQ?n8^@eL#e|WLi}V=Pe7I6J1cqgyxxy* zmVSS?dOCTzd9-=Hlmz42CzV94Moh-^Q0{)K2LYDPR&-Hy>C!=$$)laiK8?dy>xxSy z$97*TC@St#&BQ;|B636|d+xB}pAZQc!|QaTrssid7M#^B=PO$#u~Vcl9gPf|wu&xv z6w0f$jxr=>85u5cz)+5K@}?K2qOcrqe09{EOmbf9HIL z35$qopg+rdI+DO-CkC;*+{t@DZoWrp*P9}7Uf4xH$eW9(Ox1q3zcxp;>B)1AFyMO{ z8WN{GEzF_<-n||P6mKziR2jN2Thf*gVR$DOFiPUf)M$VH>Xh_8H?@>4dG+t>=OgXH zY+XQ%qZCyc)y+9O#TKEusF)}CneJn;a?wzG@KIGg{W>t+k_2(*>dfRkE7)C~-j_Ep z$N|lZhQ9~vuwPr?FP_#>xTFiie($^AJ8-b1OP(--J_3;GgSmuE38 zZ3!lR(Xp|jzQZF8oehoteRT}PSTcc7doQ8mRy@@S$kDu^`!Sn9jB|z9hWHi=j$s$S z)KDefD3F!{%(;YhY;1YU-I*SMhZ$5WR@#`RJ=#I&%IUBoREQj?Cg|b5^o4cST+8sm z0UZuP#V!^(30q8J@@!T_n<^LPb#r6UZV}4Gr=5SC&7tA~r@OAom)r|*75q?uFwkhj zcY5lT^g8fwF0Kv~1#o7j5XFX~6{^;eVU@a3!wWegGKT`NdDt0uC~Vv)^5k^a0#g4i zmNGIuxbse@vm{|FP~=F75pg9GOAyHpoYnpbCHcHg5}Yj@swe=k%^^|Tk)nnJuN$gX zYlwzI---J#tM>QcUtiJLqslVwl6m2&+PdIFy_f3~8Ct^o0!jLuLG2*07p9$!tD z;pLR`ltf~9OUNtthb;ZIB@Y!M9OlLg>GC+;fNB%i{B7nr#N2OxN(r5P zUG#MBjVsL1VjKr}a*^s`zj}vvGcX!chw)lBxV*2X3~&yyy~WaZ#6-)-HsK$6@~jgU zH#)H_gQ8F>6I7p{zK@rURObM(G?uFk0B5gh52#UPX-;gPr~w(Vkje~{zlTGi;}+rS zdgI?ys5iCdBMP!yohFV19WqKY5l6=oO2c5H$$X-r6t`idtB+(cnMZkrA*UJ_X%>dLLc!!mQqoUYH+n{ zs5rtXy|= zZPZH&m@O!I)YJbxtME&N-(7yYVVwISadNotuftAG_dsjc; zpET_D$i9}=@`#BK}E*HUd$Sl<$2^T8SnL`a9DQ>G^FcMQPATC|KcQXnu?)7XAcSK4C zw8I|{s$q_HdPfO|PBV>_5Oujz#yqSU-hXx{#yY2eeJLPSQEoMiCJb zUU0s$f%z$R&)AEDh>XRk1zqk;%CArc%bwNn6Kl7+u-+UcK=Y1H6PYXONNR>4g-v0D z@Rih%@rDa#8Kd4~#P4pnT+rgUMTXn=&>e`x^J6;u88h8AIWUy6RFWISbKh}aWzwa6 z&8fN%r&p=j?Q^gc#;fqdM0KYRqtA=cx;s!q6+&=s{T$P*R0lgGav;8H#xc$2vzl`J zcHZLGnw-&1fS+8D#Q?5fPc=Vq)z$^hKi8)Tfr)o7i@qirfr-xtJBQx}thF9pj+^$L z>Al`5R|(fYw6m~{pfmh*)kh`li3>t1dUTGH=ycZEvi6MAq)1sHjw8kJXXGE!P<8V6 z2cj)ZaEH_d`M{OtwdU8w*;i)0gtn&12+DcY?QNGDHZqN{i65gipXdwo#4;;lX$qnf zF1j_a{TY9_U@j&>Dn$ReFo@l-O%t;vv>!GLIdl@2_PalU{wx924v#$6Qgyv%6BJ@C z^14IO2WP87CgT1pQdNRsm+o#N9m%4HK*`+(Qs51yZ6ZvUZ*M8MuE{1`tnw+Qv+w1; z4cF|k#z4af4HLKR?jwR*Yql8ZGV6%?t;IfNg}dL@Yf+m8Axye?E}0+pJCAvl4;e#q z_Oos8vn186HgSJH8cAYB8U**ZT@<0CO%n+rfSB=oC`b&O*Aj&|AhbTyH@T{d#`VCI z7P!A)Tu70A*o{$t-lPN!8z3Wa!eCYYt!`&q7pNGErwU;X#$+*lcMi8DZQUJG3_MS& zRB+y=%=cm#Av^FGe0ql?isZMSgWDPN{K(f>YfIWW-l#lo;}lS7m_qw)&h|wqtM!-2 z4l|LBsOdL0Mt~SgFp@VN51;IS=m|mu-6kJkGQb696dl<_;)CZ|`@GKESV+z)g&KBt>7#1@hj#9q0;8*4qoOUU3dV zR83bIiGpouuT&RiTq!C#gCZYNhFn|MI@D}CjG*7Nyii`+5SM4d`xhL%0A(&1YXw>6 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

#n`nMw+?205NWk-U%BQNodMaTCsD|0CJt%)Go3 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

~Blss{#xK0i^Pi7cW8Vv7H7vu- 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%0D=PCV>OA%2S@G%Gb!n?GfsxE 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

YG#dFVrtr=8uP7BH77Yc}jS4H{L~hj0>*>ae$mN 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"Y2&W-&cwc38ae}cKE&URlOygNAigCIVJt=`$; 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 literal 0 HcmV?d00001 diff --git a/libssh/.arcconfig b/libssh/.arcconfig deleted file mode 100644 index 30b1a60c..00000000 --- a/libssh/.arcconfig +++ /dev/null @@ -1,4 +0,0 @@ -{ - "phabricator.uri" : "https://bugs.libssh.org/", - "history.immutable": true -} diff --git a/libssh/.editorconfig b/libssh/.editorconfig deleted file mode 100644 index 59eb92bc..00000000 --- a/libssh/.editorconfig +++ /dev/null @@ -1,18 +0,0 @@ -root = true - -[*] -charset = utf-8 -max_line_length = 80 -end_of_line = lf -trim_trailing_whitespace = true -insert_final_newline = true - -[*.{c,h}] -indent_style = space -indent_size = 4 -tab_width = 4 - -[{CMakeLists.txt,*.cmake}] -indent_style = space -indent_size = 4 -tab_width = 4 \ No newline at end of file diff --git a/libssh/CHANGELOG b/libssh/CHANGELOG index ffeb5ff8..d245fe10 100644 --- a/libssh/CHANGELOG +++ b/libssh/CHANGELOG @@ -1,5 +1,12 @@ CHANGELOG ========= +version 0.10.6 (released 2023-12-18) + * Fix CVE-2023-6004: Command injection using proxycommand + * Fix CVE-2023-48795: Potential downgrade attack using strict kex + * Fix CVE-2023-6918: Missing checks for return values of MD functions + * Fix ssh_send_issue_banner() for CMD(PowerShell) + * Avoid passing other events to callbacks when poll is called recursively (#202) + * Allow @ in usernames when parsing from URI composes version 0.10.5 (released 2023-05-04) * Fix CVE-2023-1667: a NULL dereference during rekeying with algorithm guessing diff --git a/libssh/CMakeLists.txt b/libssh/CMakeLists.txt index c3565f0d..a64b7708 100644 --- a/libssh/CMakeLists.txt +++ b/libssh/CMakeLists.txt @@ -10,7 +10,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules") include(DefineCMakeDefaults) include(DefineCompilerFlags) -project(libssh VERSION 0.10.5 LANGUAGES C) +project(libssh VERSION 0.10.6 LANGUAGES C) # global needed variable set(APPLICATION_NAME ${PROJECT_NAME}) @@ -22,7 +22,7 @@ set(APPLICATION_NAME ${PROJECT_NAME}) # Increment AGE. Set REVISION to 0 # If the source code was changed, but there were no interface changes: # Increment REVISION. -set(LIBRARY_VERSION "4.9.5") +set(LIBRARY_VERSION "4.9.6") set(LIBRARY_SOVERSION "4") # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked diff --git a/libssh/INSTALL b/libssh/INSTALL index 6e9fbf13..7ba53c50 100644 --- a/libssh/INSTALL +++ b/libssh/INSTALL @@ -19,6 +19,7 @@ optional: - [nss_wrapper](https://cwrap.org/) >= 1.1.2 - [uid_wrapper](https://cwrap.org/) >= 1.2.0 - [pam_wrapper](https://cwrap.org/) >= 1.0.1 +- [priv_wrapper](https://cwrap.org/) >= 1.0.0 Note that these version numbers are version we know works correctly. If you build and run libssh successfully with an older version, please let us know. diff --git a/libssh/doc/mainpage.dox b/libssh/doc/mainpage.dox index eba140dc..159d6779 100644 --- a/libssh/doc/mainpage.dox +++ b/libssh/doc/mainpage.dox @@ -213,15 +213,15 @@ It was later modified and expanded by the following RFCs. Use of RSA Keys with SHA-256 and SHA-512 in the Secure Shell (SSH) Protocol - RFC 8709, Ed25519 and Ed448 Public Key Algorithms for the Secure Shell (SSH) Protocol + - RFC 8731, + Secure Shell (SSH) Key Exchange Method Using Curve25519 and Curve448 + - RFC 9142, + Key Exchange (KEX) Method Updates and Recommendations for Secure Shell (SSH) There are also drafts that are being currently developed and followed. - - draft-ietf-curdle-ssh-kex-sha2-10 - Key Exchange (KEX) Method Updates and Recommendations for Secure Shell (SSH) - - draft-miller-ssh-agent-03 + - draft-miller-ssh-agent-08 SSH Agent Protocol - - draft-ietf-curdle-ssh-curves-12 - Secure Shell (SSH) Key Exchange Method using Curve25519 and Curve448 Interesting cryptography documents: diff --git a/libssh/include/libssh/config_parser.h b/libssh/include/libssh/config_parser.h index a7dd42a2..ca353432 100644 --- a/libssh/include/libssh/config_parser.h +++ b/libssh/include/libssh/config_parser.h @@ -30,6 +30,8 @@ extern "C" { #endif +#include + char *ssh_config_get_cmd(char **str); char *ssh_config_get_token(char **str); @@ -49,14 +51,17 @@ int ssh_config_get_yesno(char **str, int notfound); * be stored or NULL if we do not care about the result. * @param[out] port Pointer to the location, where the new port will * be stored or NULL if we do not care about the result. + * @param[in] ignore_port Set to true if the we should not attempt to parse + * port number. * * @returns SSH_OK if the provided string is in format of SSH URI, * SSH_ERROR on failure */ int ssh_config_parse_uri(const char *tok, - char **username, - char **hostname, - char **port); + char **username, + char **hostname, + char **port, + bool ignore_port); #ifdef __cplusplus } diff --git a/libssh/include/libssh/kex.h b/libssh/include/libssh/kex.h index ede7fa8a..ba98fded 100644 --- a/libssh/include/libssh/kex.h +++ b/libssh/include/libssh/kex.h @@ -40,6 +40,7 @@ SSH_PACKET_CALLBACK(ssh_packet_kexinit); int ssh_send_kex(ssh_session session); void ssh_list_kex(struct ssh_kex_struct *kex); int ssh_set_client_kex(ssh_session session); +int ssh_kex_append_extensions(ssh_session session, struct ssh_kex_struct *pkex); int ssh_kex_select_methods(ssh_session session); int ssh_verify_existing_algo(enum ssh_kex_types_e algo, const char *name); char *ssh_keep_known_algos(enum ssh_kex_types_e algo, const char *list); diff --git a/libssh/include/libssh/libcrypto.h b/libssh/include/libssh/libcrypto.h index 16e5f98f..87f30a4d 100644 --- a/libssh/include/libssh/libcrypto.h +++ b/libssh/include/libssh/libcrypto.h @@ -39,11 +39,6 @@ typedef EVP_MD_CTX* SHA384CTX; typedef EVP_MD_CTX* SHA512CTX; typedef EVP_MD_CTX* MD5CTX; typedef EVP_MD_CTX* HMACCTX; -#ifdef HAVE_ECC -typedef EVP_MD_CTX *EVPCTX; -#else -typedef void *EVPCTX; -#endif #define SHA_DIGEST_LEN SHA_DIGEST_LENGTH #define SHA256_DIGEST_LEN SHA256_DIGEST_LENGTH diff --git a/libssh/include/libssh/libgcrypt.h b/libssh/include/libssh/libgcrypt.h index e4087fd2..c6afc22e 100644 --- a/libssh/include/libssh/libgcrypt.h +++ b/libssh/include/libssh/libgcrypt.h @@ -32,7 +32,6 @@ typedef gcry_md_hd_t SHA384CTX; typedef gcry_md_hd_t SHA512CTX; typedef gcry_md_hd_t MD5CTX; typedef gcry_md_hd_t HMACCTX; -typedef gcry_md_hd_t EVPCTX; #define SHA_DIGEST_LENGTH 20 #define SHA_DIGEST_LEN SHA_DIGEST_LENGTH #define MD5_DIGEST_LEN 16 diff --git a/libssh/include/libssh/libmbedcrypto.h b/libssh/include/libssh/libmbedcrypto.h index e6fc393c..540a025b 100644 --- a/libssh/include/libssh/libmbedcrypto.h +++ b/libssh/include/libssh/libmbedcrypto.h @@ -41,7 +41,6 @@ typedef mbedtls_md_context_t *SHA384CTX; typedef mbedtls_md_context_t *SHA512CTX; typedef mbedtls_md_context_t *MD5CTX; typedef mbedtls_md_context_t *HMACCTX; -typedef mbedtls_md_context_t *EVPCTX; #define SHA_DIGEST_LENGTH 20 #define SHA_DIGEST_LEN SHA_DIGEST_LENGTH diff --git a/libssh/include/libssh/misc.h b/libssh/include/libssh/misc.h index 924da533..0924ba7f 100644 --- a/libssh/include/libssh/misc.h +++ b/libssh/include/libssh/misc.h @@ -103,6 +103,9 @@ int ssh_newline_vis(const char *string, char *buf, size_t buf_len); int ssh_tmpname(char *name); char *ssh_strreplace(const char *src, const char *pattern, const char *repl); + +int ssh_check_hostname_syntax(const char *hostname); + #ifdef __cplusplus } #endif diff --git a/libssh/include/libssh/packet.h b/libssh/include/libssh/packet.h index 7f10a709..f0c8cb20 100644 --- a/libssh/include/libssh/packet.h +++ b/libssh/include/libssh/packet.h @@ -67,6 +67,7 @@ SSH_PACKET_CALLBACK(ssh_packet_ext_info); SSH_PACKET_CALLBACK(ssh_packet_kexdh_init); #endif +int ssh_packet_send_newkeys(ssh_session session); int ssh_packet_send_unimplemented(ssh_session session, uint32_t seqnum); int ssh_packet_parse_type(ssh_session session); //int packet_flush(ssh_session session, int enforce_blocking); diff --git a/libssh/include/libssh/session.h b/libssh/include/libssh/session.h index eb14e97a..97936195 100644 --- a/libssh/include/libssh/session.h +++ b/libssh/include/libssh/session.h @@ -81,6 +81,12 @@ enum ssh_pending_call_e { * sending it twice during key exchange to simplify the state machine. */ #define SSH_SESSION_FLAG_KEXINIT_SENT 4 +/* The current SSH2 session implements the "strict KEX" feature and should behave + * differently on SSH2_MSG_NEWKEYS. */ +#define SSH_SESSION_FLAG_KEX_STRICT 0x0010 +/* Unexpected packets have been sent while the session was still unencrypted */ +#define SSH_SESSION_FLAG_KEX_TAINTED 0x0020 + /* codes to use with ssh_handle_packets*() */ /* Infinite timeout */ #define SSH_TIMEOUT_INFINITE -1 diff --git a/libssh/include/libssh/wrapper.h b/libssh/include/libssh/wrapper.h index 36589cff..b3e28eac 100644 --- a/libssh/include/libssh/wrapper.h +++ b/libssh/include/libssh/wrapper.h @@ -72,33 +72,33 @@ struct ssh_crypto_struct; typedef struct ssh_mac_ctx_struct *ssh_mac_ctx; MD5CTX md5_init(void); -void md5_update(MD5CTX c, const void *data, size_t len); -void md5_final(unsigned char *md,MD5CTX c); +void md5_ctx_free(MD5CTX); +int md5_update(MD5CTX c, const void *data, size_t len); +int md5_final(unsigned char *md, MD5CTX c); SHACTX sha1_init(void); -void sha1_update(SHACTX c, const void *data, size_t len); -void sha1_final(unsigned char *md,SHACTX c); -void sha1(const unsigned char *digest,size_t len,unsigned char *hash); +void sha1_ctx_free(SHACTX); +int sha1_update(SHACTX c, const void *data, size_t len); +int sha1_final(unsigned char *md,SHACTX c); +int sha1(const unsigned char *digest,size_t len, unsigned char *hash); SHA256CTX sha256_init(void); -void sha256_update(SHA256CTX c, const void *data, size_t len); -void sha256_final(unsigned char *md,SHA256CTX c); -void sha256(const unsigned char *digest, size_t len, unsigned char *hash); +void sha256_ctx_free(SHA256CTX); +int sha256_update(SHA256CTX c, const void *data, size_t len); +int sha256_final(unsigned char *md,SHA256CTX c); +int sha256(const unsigned char *digest, size_t len, unsigned char *hash); SHA384CTX sha384_init(void); -void sha384_update(SHA384CTX c, const void *data, size_t len); -void sha384_final(unsigned char *md,SHA384CTX c); -void sha384(const unsigned char *digest, size_t len, unsigned char *hash); +void sha384_ctx_free(SHA384CTX); +int sha384_update(SHA384CTX c, const void *data, size_t len); +int sha384_final(unsigned char *md,SHA384CTX c); +int sha384(const unsigned char *digest, size_t len, unsigned char *hash); SHA512CTX sha512_init(void); -void sha512_update(SHA512CTX c, const void *data, size_t len); -void sha512_final(unsigned char *md,SHA512CTX c); -void sha512(const unsigned char *digest, size_t len, unsigned char *hash); - -void evp(int nid, unsigned char *digest, size_t len, unsigned char *hash, unsigned int *hlen); -EVPCTX evp_init(int nid); -void evp_update(EVPCTX ctx, const void *data, size_t len); -void evp_final(EVPCTX ctx, unsigned char *md, unsigned int *mdlen); +void sha512_ctx_free(SHA512CTX); +int sha512_update(SHA512CTX c, const void *data, size_t len); +int sha512_final(unsigned char *md,SHA512CTX c); +int sha512(const unsigned char *digest, size_t len, unsigned char *hash); HMACCTX hmac_init(const void *key,size_t len, enum ssh_hmac_e type); int hmac_update(HMACCTX c, const void *data, size_t len); diff --git a/libssh/src/ABI/current b/libssh/src/ABI/current index efd4ffca..14d8a90b 100644 --- a/libssh/src/ABI/current +++ b/libssh/src/ABI/current @@ -1 +1 @@ -4.9.5 \ No newline at end of file +4.9.6 \ No newline at end of file diff --git a/libssh/src/ABI/libssh-4.9.6.symbols b/libssh/src/ABI/libssh-4.9.6.symbols new file mode 100644 index 00000000..a26e2c5e --- /dev/null +++ b/libssh/src/ABI/libssh-4.9.6.symbols @@ -0,0 +1,427 @@ +_ssh_log +buffer_free +buffer_get +buffer_get_len +buffer_new +channel_accept_x11 +channel_change_pty_size +channel_close +channel_forward_accept +channel_forward_cancel +channel_forward_listen +channel_free +channel_get_exit_status +channel_get_session +channel_is_closed +channel_is_eof +channel_is_open +channel_new +channel_open_forward +channel_open_session +channel_poll +channel_read +channel_read_buffer +channel_read_nonblocking +channel_request_env +channel_request_exec +channel_request_pty +channel_request_pty_size +channel_request_send_signal +channel_request_sftp +channel_request_shell +channel_request_subsystem +channel_request_x11 +channel_select +channel_send_eof +channel_set_blocking +channel_write +channel_write_stderr +privatekey_free +privatekey_from_file +publickey_free +publickey_from_file +publickey_from_privatekey +publickey_to_string +sftp_async_read +sftp_async_read_begin +sftp_attributes_free +sftp_canonicalize_path +sftp_chmod +sftp_chown +sftp_client_message_free +sftp_client_message_get_data +sftp_client_message_get_filename +sftp_client_message_get_flags +sftp_client_message_get_submessage +sftp_client_message_get_type +sftp_client_message_set_filename +sftp_close +sftp_closedir +sftp_dir_eof +sftp_extension_supported +sftp_extensions_get_count +sftp_extensions_get_data +sftp_extensions_get_name +sftp_file_set_blocking +sftp_file_set_nonblocking +sftp_free +sftp_fstat +sftp_fstatvfs +sftp_fsync +sftp_get_client_message +sftp_get_error +sftp_handle +sftp_handle_alloc +sftp_handle_remove +sftp_init +sftp_lstat +sftp_mkdir +sftp_new +sftp_new_channel +sftp_open +sftp_opendir +sftp_read +sftp_readdir +sftp_readlink +sftp_rename +sftp_reply_attr +sftp_reply_data +sftp_reply_handle +sftp_reply_name +sftp_reply_names +sftp_reply_names_add +sftp_reply_status +sftp_rewind +sftp_rmdir +sftp_seek +sftp_seek64 +sftp_send_client_message +sftp_server_free +sftp_server_init +sftp_server_new +sftp_server_version +sftp_setstat +sftp_stat +sftp_statvfs +sftp_statvfs_free +sftp_symlink +sftp_tell +sftp_tell64 +sftp_unlink +sftp_utimes +sftp_write +ssh_accept +ssh_add_channel_callbacks +ssh_auth_list +ssh_basename +ssh_bind_accept +ssh_bind_accept_fd +ssh_bind_fd_toaccept +ssh_bind_free +ssh_bind_get_fd +ssh_bind_listen +ssh_bind_new +ssh_bind_options_parse_config +ssh_bind_options_set +ssh_bind_set_blocking +ssh_bind_set_callbacks +ssh_bind_set_fd +ssh_blocking_flush +ssh_buffer_add_data +ssh_buffer_free +ssh_buffer_get +ssh_buffer_get_data +ssh_buffer_get_len +ssh_buffer_new +ssh_buffer_reinit +ssh_channel_accept_forward +ssh_channel_accept_x11 +ssh_channel_cancel_forward +ssh_channel_change_pty_size +ssh_channel_close +ssh_channel_free +ssh_channel_get_exit_status +ssh_channel_get_session +ssh_channel_is_closed +ssh_channel_is_eof +ssh_channel_is_open +ssh_channel_listen_forward +ssh_channel_new +ssh_channel_open_auth_agent +ssh_channel_open_forward +ssh_channel_open_forward_port +ssh_channel_open_forward_unix +ssh_channel_open_reverse_forward +ssh_channel_open_session +ssh_channel_open_x11 +ssh_channel_poll +ssh_channel_poll_timeout +ssh_channel_read +ssh_channel_read_nonblocking +ssh_channel_read_timeout +ssh_channel_request_auth_agent +ssh_channel_request_env +ssh_channel_request_exec +ssh_channel_request_pty +ssh_channel_request_pty_size +ssh_channel_request_send_break +ssh_channel_request_send_exit_signal +ssh_channel_request_send_exit_status +ssh_channel_request_send_signal +ssh_channel_request_sftp +ssh_channel_request_shell +ssh_channel_request_subsystem +ssh_channel_request_x11 +ssh_channel_select +ssh_channel_send_eof +ssh_channel_set_blocking +ssh_channel_set_counter +ssh_channel_window_size +ssh_channel_write +ssh_channel_write_stderr +ssh_clean_pubkey_hash +ssh_connect +ssh_connector_free +ssh_connector_new +ssh_connector_set_in_channel +ssh_connector_set_in_fd +ssh_connector_set_out_channel +ssh_connector_set_out_fd +ssh_copyright +ssh_dirname +ssh_disconnect +ssh_dump_knownhost +ssh_event_add_connector +ssh_event_add_fd +ssh_event_add_session +ssh_event_dopoll +ssh_event_free +ssh_event_new +ssh_event_remove_connector +ssh_event_remove_fd +ssh_event_remove_session +ssh_execute_message_callbacks +ssh_finalize +ssh_forward_accept +ssh_forward_cancel +ssh_forward_listen +ssh_free +ssh_get_cipher_in +ssh_get_cipher_out +ssh_get_clientbanner +ssh_get_disconnect_message +ssh_get_error +ssh_get_error_code +ssh_get_fd +ssh_get_fingerprint_hash +ssh_get_hexa +ssh_get_hmac_in +ssh_get_hmac_out +ssh_get_issue_banner +ssh_get_kex_algo +ssh_get_log_callback +ssh_get_log_level +ssh_get_log_userdata +ssh_get_openssh_version +ssh_get_poll_flags +ssh_get_pubkey +ssh_get_pubkey_hash +ssh_get_publickey +ssh_get_publickey_hash +ssh_get_random +ssh_get_server_publickey +ssh_get_serverbanner +ssh_get_status +ssh_get_version +ssh_getpass +ssh_gssapi_get_creds +ssh_gssapi_set_creds +ssh_handle_key_exchange +ssh_init +ssh_is_blocking +ssh_is_connected +ssh_is_server_known +ssh_key_cmp +ssh_key_dup +ssh_key_free +ssh_key_is_private +ssh_key_is_public +ssh_key_new +ssh_key_type +ssh_key_type_from_name +ssh_key_type_to_char +ssh_known_hosts_parse_line +ssh_knownhosts_entry_free +ssh_log +ssh_message_auth_interactive_request +ssh_message_auth_kbdint_is_response +ssh_message_auth_password +ssh_message_auth_pubkey +ssh_message_auth_publickey +ssh_message_auth_publickey_state +ssh_message_auth_reply_pk_ok +ssh_message_auth_reply_pk_ok_simple +ssh_message_auth_reply_success +ssh_message_auth_set_methods +ssh_message_auth_user +ssh_message_channel_request_channel +ssh_message_channel_request_command +ssh_message_channel_request_env_name +ssh_message_channel_request_env_value +ssh_message_channel_request_open_destination +ssh_message_channel_request_open_destination_port +ssh_message_channel_request_open_originator +ssh_message_channel_request_open_originator_port +ssh_message_channel_request_open_reply_accept +ssh_message_channel_request_open_reply_accept_channel +ssh_message_channel_request_pty_height +ssh_message_channel_request_pty_pxheight +ssh_message_channel_request_pty_pxwidth +ssh_message_channel_request_pty_term +ssh_message_channel_request_pty_width +ssh_message_channel_request_reply_success +ssh_message_channel_request_subsystem +ssh_message_channel_request_x11_auth_cookie +ssh_message_channel_request_x11_auth_protocol +ssh_message_channel_request_x11_screen_number +ssh_message_channel_request_x11_single_connection +ssh_message_free +ssh_message_get +ssh_message_global_request_address +ssh_message_global_request_port +ssh_message_global_request_reply_success +ssh_message_reply_default +ssh_message_retrieve +ssh_message_service_reply_success +ssh_message_service_service +ssh_message_subtype +ssh_message_type +ssh_mkdir +ssh_new +ssh_options_copy +ssh_options_get +ssh_options_get_port +ssh_options_getopt +ssh_options_parse_config +ssh_options_set +ssh_pcap_file_close +ssh_pcap_file_free +ssh_pcap_file_new +ssh_pcap_file_open +ssh_pki_copy_cert_to_privkey +ssh_pki_export_privkey_base64 +ssh_pki_export_privkey_file +ssh_pki_export_privkey_to_pubkey +ssh_pki_export_pubkey_base64 +ssh_pki_export_pubkey_file +ssh_pki_generate +ssh_pki_import_cert_base64 +ssh_pki_import_cert_file +ssh_pki_import_privkey_base64 +ssh_pki_import_privkey_file +ssh_pki_import_pubkey_base64 +ssh_pki_import_pubkey_file +ssh_pki_key_ecdsa_name +ssh_print_hash +ssh_print_hexa +ssh_privatekey_type +ssh_publickey_to_file +ssh_remove_channel_callbacks +ssh_scp_accept_request +ssh_scp_close +ssh_scp_deny_request +ssh_scp_free +ssh_scp_init +ssh_scp_leave_directory +ssh_scp_new +ssh_scp_pull_request +ssh_scp_push_directory +ssh_scp_push_file +ssh_scp_push_file64 +ssh_scp_read +ssh_scp_request_get_filename +ssh_scp_request_get_permissions +ssh_scp_request_get_size +ssh_scp_request_get_size64 +ssh_scp_request_get_warning +ssh_scp_write +ssh_select +ssh_send_debug +ssh_send_ignore +ssh_send_issue_banner +ssh_send_keepalive +ssh_server_init_kex +ssh_service_request +ssh_session_export_known_hosts_entry +ssh_session_get_known_hosts_entry +ssh_session_has_known_hosts_entry +ssh_session_is_known_server +ssh_session_set_disconnect_message +ssh_session_update_known_hosts +ssh_set_agent_channel +ssh_set_agent_socket +ssh_set_auth_methods +ssh_set_blocking +ssh_set_callbacks +ssh_set_channel_callbacks +ssh_set_counters +ssh_set_fd_except +ssh_set_fd_toread +ssh_set_fd_towrite +ssh_set_log_callback +ssh_set_log_level +ssh_set_log_userdata +ssh_set_message_callback +ssh_set_pcap_file +ssh_set_server_callbacks +ssh_silent_disconnect +ssh_string_burn +ssh_string_copy +ssh_string_data +ssh_string_fill +ssh_string_free +ssh_string_free_char +ssh_string_from_char +ssh_string_get_char +ssh_string_len +ssh_string_new +ssh_string_to_char +ssh_threads_get_default +ssh_threads_get_noop +ssh_threads_get_pthread +ssh_threads_set_callbacks +ssh_try_publickey_from_file +ssh_userauth_agent +ssh_userauth_agent_pubkey +ssh_userauth_autopubkey +ssh_userauth_gssapi +ssh_userauth_kbdint +ssh_userauth_kbdint_getanswer +ssh_userauth_kbdint_getinstruction +ssh_userauth_kbdint_getname +ssh_userauth_kbdint_getnanswers +ssh_userauth_kbdint_getnprompts +ssh_userauth_kbdint_getprompt +ssh_userauth_kbdint_setanswer +ssh_userauth_list +ssh_userauth_none +ssh_userauth_offer_pubkey +ssh_userauth_password +ssh_userauth_privatekey_file +ssh_userauth_pubkey +ssh_userauth_publickey +ssh_userauth_publickey_auto +ssh_userauth_publickey_auto_get_current_identity +ssh_userauth_try_publickey +ssh_version +ssh_vlog +ssh_write_knownhost +string_burn +string_copy +string_data +string_fill +string_free +string_from_char +string_len +string_new +string_to_char \ No newline at end of file diff --git a/libssh/src/CMakeLists.txt b/libssh/src/CMakeLists.txt index d6245c0d..807313b5 100644 --- a/libssh/src/CMakeLists.txt +++ b/libssh/src/CMakeLists.txt @@ -91,6 +91,7 @@ endif() if (WIN32) set(LIBSSH_LINK_LIBRARIES ${LIBSSH_LINK_LIBRARIES} + iphlpapi ws2_32 ) endif (WIN32) diff --git a/libssh/src/channels.c b/libssh/src/channels.c index f2fe39aa..ab6915a2 100644 --- a/libssh/src/channels.c +++ b/libssh/src/channels.c @@ -3525,9 +3525,15 @@ int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans, firstround=0; } while(1); - memcpy(readchans, rchans, (count_ptrs(rchans) + 1) * sizeof(ssh_channel )); - memcpy(writechans, wchans, (count_ptrs(wchans) + 1) * sizeof(ssh_channel )); - memcpy(exceptchans, echans, (count_ptrs(echans) + 1) * sizeof(ssh_channel )); + if (readchans != &dummy) { + memcpy(readchans, rchans, (count_ptrs(rchans) + 1) * sizeof(ssh_channel)); + } + if (writechans != &dummy) { + memcpy(writechans, wchans, (count_ptrs(wchans) + 1) * sizeof(ssh_channel)); + } + if (exceptchans != &dummy) { + memcpy(exceptchans, echans, (count_ptrs(echans) + 1) * sizeof(ssh_channel)); + } SAFE_FREE(rchans); SAFE_FREE(wchans); SAFE_FREE(echans); diff --git a/libssh/src/config.c b/libssh/src/config.c index c5c40125..273db7c8 100644 --- a/libssh/src/config.c +++ b/libssh/src/config.c @@ -464,7 +464,7 @@ ssh_config_parse_proxy_jump(ssh_session session, const char *s, bool do_parsing) } if (parse_entry) { /* We actually care only about the first item */ - rv = ssh_config_parse_uri(cp, &username, &hostname, &port); + rv = ssh_config_parse_uri(cp, &username, &hostname, &port, false); /* The rest of the list needs to be passed on */ if (endp != NULL) { next = strdup(endp + 1); @@ -475,7 +475,7 @@ ssh_config_parse_proxy_jump(ssh_session session, const char *s, bool do_parsing) } } else { /* The rest is just sanity-checked to avoid failures later */ - rv = ssh_config_parse_uri(cp, NULL, NULL, NULL); + rv = ssh_config_parse_uri(cp, NULL, NULL, NULL, false); } if (rv != SSH_OK) { goto out; diff --git a/libssh/src/config_parser.c b/libssh/src/config_parser.c index 0d988fec..d4b2d2c3 100644 --- a/libssh/src/config_parser.c +++ b/libssh/src/config_parser.c @@ -30,6 +30,7 @@ #include "libssh/config_parser.h" #include "libssh/priv.h" +#include "libssh/misc.h" /* Returns the original string after skipping the leading whitespace * until finding LF. @@ -47,7 +48,7 @@ char *ssh_config_get_cmd(char **str) break; } } - + for (r = c; *c; c++) { if (*c == '\n') { *c = '\0'; @@ -161,12 +162,14 @@ int ssh_config_get_yesno(char **str, int notfound) } int ssh_config_parse_uri(const char *tok, - char **username, - char **hostname, - char **port) + char **username, + char **hostname, + char **port, + bool ignore_port) { char *endp = NULL; long port_n; + int rc; /* Sanitize inputs */ if (username != NULL) { @@ -180,7 +183,7 @@ int ssh_config_parse_uri(const char *tok, } /* Username part (optional) */ - endp = strchr(tok, '@'); + endp = strrchr(tok, '@'); if (endp != NULL) { /* Zero-length username is not valid */ if (tok == endp) { @@ -208,12 +211,17 @@ int ssh_config_parse_uri(const char *tok, if (endp == NULL) { goto error; } - } else { - /* Hostnames or aliases expand to the last colon or to the end */ + } else if (!ignore_port) { + /* Hostnames or aliases expand to the last colon (if port is requested) + * or to the end */ endp = strrchr(tok, ':'); if (endp == NULL) { endp = strchr(tok, '\0'); } + } else { + /* If no port is requested, expand to the end of line + * (to accommodate the IPv6 addresses) */ + endp = strchr(tok, '\0'); } if (tok == endp) { /* Zero-length hostnames are not valid */ @@ -224,6 +232,14 @@ int ssh_config_parse_uri(const char *tok, if (*hostname == NULL) { goto error; } + /* if not an ip, check syntax */ + rc = ssh_is_ipaddr(*hostname); + if (rc == 0) { + rc = ssh_check_hostname_syntax(*hostname); + if (rc != SSH_OK) { + goto error; + } + } } /* Skip also the closing bracket */ if (*endp == ']') { diff --git a/libssh/src/connect.c b/libssh/src/connect.c index 57e37e63..15cae644 100644 --- a/libssh/src/connect.c +++ b/libssh/src/connect.c @@ -136,7 +136,7 @@ static int getai(const char *host, int port, struct addrinfo **ai) #endif } - if (ssh_is_ipaddr(host)) { + if (ssh_is_ipaddr(host) == 1) { /* this is an IP address */ SSH_LOG(SSH_LOG_PACKET, "host %s matches an IP address", host); hints.ai_flags |= AI_NUMERICHOST; diff --git a/libssh/src/curve25519.c b/libssh/src/curve25519.c index 66291b5f..4aeb4756 100644 --- a/libssh/src/curve25519.c +++ b/libssh/src/curve25519.c @@ -335,16 +335,10 @@ static SSH_PACKET_CALLBACK(ssh_packet_client_curve25519_reply){ } /* Send the MSG_NEWKEYS */ - if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) { - goto error; - } - - rc=ssh_packet_send(session); + rc = ssh_packet_send_newkeys(session); if (rc == SSH_ERROR) { goto error; } - - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; return SSH_PACKET_USED; @@ -502,18 +496,13 @@ static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){ return SSH_ERROR; } - /* Send the MSG_NEWKEYS */ - rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS); - if (rc < 0) { - goto error; - } - session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; - rc = ssh_packet_send(session); + + /* Send the MSG_NEWKEYS */ + rc = ssh_packet_send_newkeys(session); if (rc == SSH_ERROR) { goto error; } - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); return SSH_PACKET_USED; error: diff --git a/libssh/src/dh-gex.c b/libssh/src/dh-gex.c index 91617081..642a88ae 100644 --- a/libssh/src/dh-gex.c +++ b/libssh/src/dh-gex.c @@ -297,15 +297,10 @@ static SSH_PACKET_CALLBACK(ssh_packet_client_dhgex_reply) } /* Send the MSG_NEWKEYS */ - if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) { - goto error; - } - - rc = ssh_packet_send(session); + rc = ssh_packet_send_newkeys(session); if (rc == SSH_ERROR) { goto error; } - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; return SSH_PACKET_USED; diff --git a/libssh/src/dh.c b/libssh/src/dh.c index 011d97b3..e19e43d1 100644 --- a/libssh/src/dh.c +++ b/libssh/src/dh.c @@ -398,16 +398,10 @@ SSH_PACKET_CALLBACK(ssh_packet_client_dh_reply){ } /* Send the MSG_NEWKEYS */ - if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) { - goto error; - } - - rc=ssh_packet_send(session); + rc = ssh_packet_send_newkeys(session); if (rc == SSH_ERROR) { goto error; } - - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; return SSH_PACKET_USED; error: @@ -551,15 +545,12 @@ int ssh_server_dh_process_init(ssh_session session, ssh_buffer packet) } SSH_LOG(SSH_LOG_DEBUG, "Sent KEX_DH_[GEX]_REPLY"); - if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) { - ssh_buffer_reinit(session->out_buffer); - goto error; - } session->dh_handshake_state=DH_STATE_NEWKEYS_SENT; - if (ssh_packet_send(session) == SSH_ERROR) { + /* Send the MSG_NEWKEYS */ + rc = ssh_packet_send_newkeys(session); + if (rc == SSH_ERROR) { goto error; } - SSH_LOG(SSH_LOG_PACKET, "SSH_MSG_NEWKEYS sent"); return SSH_OK; error: diff --git a/libssh/src/ecdh.c b/libssh/src/ecdh.c index e5b11ba9..af80beec 100644 --- a/libssh/src/ecdh.c +++ b/libssh/src/ecdh.c @@ -93,16 +93,10 @@ SSH_PACKET_CALLBACK(ssh_packet_client_ecdh_reply){ } /* Send the MSG_NEWKEYS */ - if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) { - goto error; - } - - rc=ssh_packet_send(session); + rc = ssh_packet_send_newkeys(session); if (rc == SSH_ERROR) { goto error; } - - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; return SSH_PACKET_USED; diff --git a/libssh/src/ecdh_crypto.c b/libssh/src/ecdh_crypto.c index 51084b7a..069b1372 100644 --- a/libssh/src/ecdh_crypto.c +++ b/libssh/src/ecdh_crypto.c @@ -619,18 +619,12 @@ SSH_PACKET_CALLBACK(ssh_packet_server_ecdh_init){ goto error; } - /* Send the MSG_NEWKEYS */ - rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS); - if (rc < 0) { - goto error; - } - session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; - rc = ssh_packet_send(session); - if (rc == SSH_ERROR){ + /* Send the MSG_NEWKEYS */ + rc = ssh_packet_send_newkeys(session); + if (rc == SSH_ERROR) { goto error; } - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); return SSH_PACKET_USED; error: diff --git a/libssh/src/ecdh_gcrypt.c b/libssh/src/ecdh_gcrypt.c index 235f2904..3d9d426f 100644 --- a/libssh/src/ecdh_gcrypt.c +++ b/libssh/src/ecdh_gcrypt.c @@ -372,17 +372,13 @@ SSH_PACKET_CALLBACK(ssh_packet_server_ecdh_init){ goto out; } - + session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; /* Send the MSG_NEWKEYS */ - rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS); - if (rc != SSH_OK) { + rc = ssh_packet_send_newkeys(session); + if (rc == SSH_ERROR) { goto out; } - session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; - rc = ssh_packet_send(session); - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); - out: gcry_sexp_release(param); gcry_sexp_release(key); diff --git a/libssh/src/ecdh_mbedcrypto.c b/libssh/src/ecdh_mbedcrypto.c index cfe017a0..dda73922 100644 --- a/libssh/src/ecdh_mbedcrypto.c +++ b/libssh/src/ecdh_mbedcrypto.c @@ -318,16 +318,13 @@ SSH_PACKET_CALLBACK(ssh_packet_server_ecdh_init){ goto out; } - rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS); - if (rc < 0) { - rc = SSH_ERROR; + session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; + /* Send the MSG_NEWKEYS */ + rc = ssh_packet_send_newkeys(session); + if (rc == SSH_ERROR) { goto out; } - session->dh_handshake_state = DH_STATE_NEWKEYS_SENT; - rc = ssh_packet_send(session); - SSH_LOG(SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent"); - out: mbedtls_ecp_group_free(&grp); if (rc == SSH_ERROR) { diff --git a/libssh/src/kdf.c b/libssh/src/kdf.c index 44f06631..6bc477ce 100644 --- a/libssh/src/kdf.c +++ b/libssh/src/kdf.c @@ -58,65 +58,102 @@ static ssh_mac_ctx ssh_mac_ctx_init(enum ssh_kdf_digest type) } ctx->digest_type = type; - switch(type){ + switch (type) { case SSH_KDF_SHA1: ctx->ctx.sha1_ctx = sha1_init(); + if (ctx->ctx.sha1_ctx == NULL) { + goto err; + } return ctx; case SSH_KDF_SHA256: ctx->ctx.sha256_ctx = sha256_init(); + if (ctx->ctx.sha256_ctx == NULL) { + goto err; + } return ctx; case SSH_KDF_SHA384: ctx->ctx.sha384_ctx = sha384_init(); + if (ctx->ctx.sha384_ctx == NULL) { + goto err; + } return ctx; case SSH_KDF_SHA512: ctx->ctx.sha512_ctx = sha512_init(); + if (ctx->ctx.sha512_ctx == NULL) { + goto err; + } return ctx; - default: - SAFE_FREE(ctx); - return NULL; } +err: + SAFE_FREE(ctx); + return NULL; } -static void ssh_mac_update(ssh_mac_ctx ctx, const void *data, size_t len) +static void ssh_mac_ctx_free(ssh_mac_ctx ctx) { - switch(ctx->digest_type){ + if (ctx == NULL) { + return; + } + + switch (ctx->digest_type) { case SSH_KDF_SHA1: - sha1_update(ctx->ctx.sha1_ctx, data, len); + sha1_ctx_free(ctx->ctx.sha1_ctx); break; case SSH_KDF_SHA256: - sha256_update(ctx->ctx.sha256_ctx, data, len); + sha256_ctx_free(ctx->ctx.sha256_ctx); break; case SSH_KDF_SHA384: - sha384_update(ctx->ctx.sha384_ctx, data, len); + sha384_ctx_free(ctx->ctx.sha384_ctx); break; case SSH_KDF_SHA512: - sha512_update(ctx->ctx.sha512_ctx, data, len); + sha512_ctx_free(ctx->ctx.sha512_ctx); break; } + SAFE_FREE(ctx); } -static void ssh_mac_final(unsigned char *md, ssh_mac_ctx ctx) +static int ssh_mac_update(ssh_mac_ctx ctx, const void *data, size_t len) { - switch(ctx->digest_type){ + switch (ctx->digest_type) { + case SSH_KDF_SHA1: + return sha1_update(ctx->ctx.sha1_ctx, data, len); + case SSH_KDF_SHA256: + return sha256_update(ctx->ctx.sha256_ctx, data, len); + case SSH_KDF_SHA384: + return sha384_update(ctx->ctx.sha384_ctx, data, len); + case SSH_KDF_SHA512: + return sha512_update(ctx->ctx.sha512_ctx, data, len); + } + return SSH_ERROR; +} + +static int ssh_mac_final(unsigned char *md, ssh_mac_ctx ctx) +{ + int rc = SSH_ERROR; + + switch (ctx->digest_type) { case SSH_KDF_SHA1: - sha1_final(md,ctx->ctx.sha1_ctx); + rc = sha1_final(md, ctx->ctx.sha1_ctx); break; case SSH_KDF_SHA256: - sha256_final(md,ctx->ctx.sha256_ctx); + rc = sha256_final(md, ctx->ctx.sha256_ctx); break; case SSH_KDF_SHA384: - sha384_final(md,ctx->ctx.sha384_ctx); + rc = sha384_final(md, ctx->ctx.sha384_ctx); break; case SSH_KDF_SHA512: - sha512_final(md,ctx->ctx.sha512_ctx); + rc = sha512_final(md, ctx->ctx.sha512_ctx); break; } SAFE_FREE(ctx); + return rc; } int sshkdf_derive_key(struct ssh_crypto_struct *crypto, - unsigned char *key, size_t key_len, - uint8_t key_type, unsigned char *output, + unsigned char *key, + size_t key_len, + uint8_t key_type, + unsigned char *output, size_t requested_len) { /* Can't use VLAs with Visual Studio, so allocate the biggest @@ -124,6 +161,7 @@ int sshkdf_derive_key(struct ssh_crypto_struct *crypto, unsigned char digest[DIGEST_MAX_LEN]; size_t output_len = crypto->digest_len; ssh_mac_ctx ctx; + int rc; if (DIGEST_MAX_LEN < crypto->digest_len) { return -1; @@ -134,11 +172,30 @@ int sshkdf_derive_key(struct ssh_crypto_struct *crypto, return -1; } - ssh_mac_update(ctx, key, key_len); - ssh_mac_update(ctx, crypto->secret_hash, crypto->digest_len); - ssh_mac_update(ctx, &key_type, 1); - ssh_mac_update(ctx, crypto->session_id, crypto->session_id_len); - ssh_mac_final(digest, ctx); + rc = ssh_mac_update(ctx, key, key_len); + if (rc != SSH_OK) { + ssh_mac_ctx_free(ctx); + return -1; + } + rc = ssh_mac_update(ctx, crypto->secret_hash, crypto->digest_len); + if (rc != SSH_OK) { + ssh_mac_ctx_free(ctx); + return -1; + } + rc = ssh_mac_update(ctx, &key_type, 1); + if (rc != SSH_OK) { + ssh_mac_ctx_free(ctx); + return -1; + } + rc = ssh_mac_update(ctx, crypto->session_id, crypto->session_id_len); + if (rc != SSH_OK) { + ssh_mac_ctx_free(ctx); + return -1; + } + rc = ssh_mac_final(digest, ctx); + if (rc != SSH_OK) { + return -1; + } if (requested_len < output_len) { output_len = requested_len; @@ -150,10 +207,25 @@ int sshkdf_derive_key(struct ssh_crypto_struct *crypto, if (ctx == NULL) { return -1; } - ssh_mac_update(ctx, key, key_len); - ssh_mac_update(ctx, crypto->secret_hash, crypto->digest_len); - ssh_mac_update(ctx, output, output_len); - ssh_mac_final(digest, ctx); + rc = ssh_mac_update(ctx, key, key_len); + if (rc != SSH_OK) { + ssh_mac_ctx_free(ctx); + return -1; + } + rc = ssh_mac_update(ctx, crypto->secret_hash, crypto->digest_len); + if (rc != SSH_OK) { + ssh_mac_ctx_free(ctx); + return -1; + } + rc = ssh_mac_update(ctx, output, output_len); + if (rc != SSH_OK) { + ssh_mac_ctx_free(ctx); + return -1; + } + rc = ssh_mac_final(digest, ctx); + if (rc != SSH_OK) { + return -1; + } if (requested_len < output_len + crypto->digest_len) { memcpy(output + output_len, digest, requested_len - output_len); } else { diff --git a/libssh/src/kex.c b/libssh/src/kex.c index b9455d2d..fbc70cf4 100644 --- a/libssh/src/kex.c +++ b/libssh/src/kex.c @@ -188,6 +188,9 @@ /* RFC 8308 */ #define KEX_EXTENSION_CLIENT "ext-info-c" +/* Strict kex mitigation against CVE-2023-48795 */ +#define KEX_STRICT_CLIENT "kex-strict-c-v00@openssh.com" +#define KEX_STRICT_SERVER "kex-strict-s-v00@openssh.com" /* Allowed algorithms in FIPS mode */ #define FIPS_ALLOWED_CIPHERS "aes256-gcm@openssh.com,"\ @@ -516,6 +519,27 @@ SSH_PACKET_CALLBACK(ssh_packet_kexinit) session->first_kex_follows_guess_wrong ? "wrong" : "right"); } + /* + * handle the "strict KEX" feature. If supported by peer, then set up the + * flag and verify packet sequence numbers. + */ + if (server_kex) { + ok = ssh_match_group(crypto->client_kex.methods[SSH_KEX], + KEX_STRICT_CLIENT); + if (ok) { + SSH_LOG(SSH_LOG_DEBUG, "Client supports strict kex, enabling."); + session->flags |= SSH_SESSION_FLAG_KEX_STRICT; + } + } else { + /* client kex */ + ok = ssh_match_group(crypto->server_kex.methods[SSH_KEX], + KEX_STRICT_SERVER); + if (ok) { + SSH_LOG(SSH_LOG_DEBUG, "Server supports strict kex, enabling."); + session->flags |= SSH_SESSION_FLAG_KEX_STRICT; + } + } + if (server_kex) { /* * If client sent a ext-info-c message in the kex list, it supports @@ -739,11 +763,8 @@ int ssh_set_client_kex(ssh_session session) { struct ssh_kex_struct *client = &session->next_crypto->client_kex; const char *wanted; - char *kex = NULL; - char *kex_tmp = NULL; int ok; int i; - size_t kex_len, len; /* Skip if already set, for example for the rekey or when we do the guessing * it could have been already used to make some protocol decisions. */ @@ -792,23 +813,52 @@ int ssh_set_client_kex(ssh_session session) return SSH_OK; } - /* Here we append ext-info-c to the list of kex algorithms */ - kex = client->methods[SSH_KEX]; + ok = ssh_kex_append_extensions(session, client); + if (ok != SSH_OK){ + return ok; + } + + return SSH_OK; +} + +int ssh_kex_append_extensions(ssh_session session, struct ssh_kex_struct *pkex) +{ + char *kex = NULL; + char *kex_tmp = NULL; + size_t kex_len, len; + + /* Here we append ext-info-c and kex-strict-c-v00@openssh.com for client + * and kex-strict-s-v00@openssh.com for server to the list of kex algorithms + */ + kex = pkex->methods[SSH_KEX]; len = strlen(kex); - if (len + strlen(KEX_EXTENSION_CLIENT) + 2 < len) { + if (session->server) { + /* Comma, nul byte */ + kex_len = len + 1 + strlen(KEX_STRICT_SERVER) + 1; + } else { + /* Comma, comma, nul byte */ + kex_len = len + 1 + strlen(KEX_EXTENSION_CLIENT) + 1 + + strlen(KEX_STRICT_CLIENT) + 1; + } + if (kex_len >= MAX_PACKET_LEN) { /* Overflow */ return SSH_ERROR; } - kex_len = len + strlen(KEX_EXTENSION_CLIENT) + 2; /* comma, NULL */ kex_tmp = realloc(kex, kex_len); if (kex_tmp == NULL) { - free(kex); ssh_set_error_oom(session); return SSH_ERROR; } - snprintf(kex_tmp + len, kex_len - len, ",%s", KEX_EXTENSION_CLIENT); - client->methods[SSH_KEX] = kex_tmp; - + if (session->server){ + snprintf(kex_tmp + len, kex_len - len, ",%s", KEX_STRICT_SERVER); + } else { + snprintf(kex_tmp + len, + kex_len - len, + ",%s,%s", + KEX_EXTENSION_CLIENT, + KEX_STRICT_CLIENT); + } + pkex->methods[SSH_KEX] = kex_tmp; return SSH_OK; } @@ -911,11 +961,19 @@ int ssh_kex_select_methods (ssh_session session) enum ssh_key_exchange_e kex_type; int i; - /* Here we should drop the ext-info-c from the list so we avoid matching. + /* Here we should drop the extensions from the list so we avoid matching. * it. We added it to the end, so we can just truncate the string here */ - ext_start = strstr(client->methods[SSH_KEX], ","KEX_EXTENSION_CLIENT); - if (ext_start != NULL) { - ext_start[0] = '\0'; + if (session->client) { + ext_start = strstr(client->methods[SSH_KEX], "," KEX_EXTENSION_CLIENT); + if (ext_start != NULL) { + ext_start[0] = '\0'; + } + } + if (session->server) { + ext_start = strstr(server->methods[SSH_KEX], "," KEX_STRICT_SERVER); + if (ext_start != NULL) { + ext_start[0] = '\0'; + } } for (i = 0; i < SSH_KEX_METHODS; i++) { diff --git a/libssh/src/libcrypto.c b/libssh/src/libcrypto.c index ebdca6e0..4f945d90 100644 --- a/libssh/src/libcrypto.c +++ b/libssh/src/libcrypto.c @@ -125,60 +125,6 @@ ENGINE *pki_get_engine(void) return engine; } -#ifdef HAVE_OPENSSL_ECC -static const EVP_MD *nid_to_evpmd(int nid) -{ - switch (nid) { - case NID_X9_62_prime256v1: - return EVP_sha256(); - case NID_secp384r1: - return EVP_sha384(); - case NID_secp521r1: - return EVP_sha512(); - default: - return NULL; - } - - return NULL; -} - -void evp(int nid, unsigned char *digest, size_t len, unsigned char *hash, unsigned int *hlen) -{ - const EVP_MD *evp_md = nid_to_evpmd(nid); - EVP_MD_CTX *md = EVP_MD_CTX_new(); - - EVP_DigestInit(md, evp_md); - EVP_DigestUpdate(md, digest, len); - EVP_DigestFinal(md, hash, hlen); - EVP_MD_CTX_free(md); -} - -EVPCTX evp_init(int nid) -{ - const EVP_MD *evp_md = nid_to_evpmd(nid); - - EVPCTX ctx = EVP_MD_CTX_new(); - if (ctx == NULL) { - return NULL; - } - - EVP_DigestInit(ctx, evp_md); - - return ctx; -} - -void evp_update(EVPCTX ctx, const void *data, size_t len) -{ - EVP_DigestUpdate(ctx, data, len); -} - -void evp_final(EVPCTX ctx, unsigned char *md, unsigned int *mdlen) -{ - EVP_DigestFinal(ctx, md, mdlen); - EVP_MD_CTX_free(ctx); -} -#endif /* HAVE_OPENSSL_ECC */ - #ifdef HAVE_OPENSSL_EVP_KDF_CTX #if OPENSSL_VERSION_NUMBER < 0x30000000L static const EVP_MD *sshkdf_digest_to_md(enum ssh_kdf_digest digest_type) diff --git a/libssh/src/libgcrypt.c b/libssh/src/libgcrypt.c index 2e44a53c..f410d997 100644 --- a/libssh/src/libgcrypt.c +++ b/libssh/src/libgcrypt.c @@ -69,59 +69,6 @@ static int alloc_key(struct ssh_cipher_struct *cipher) { void ssh_reseed(void){ } -#ifdef HAVE_GCRYPT_ECC -static int nid_to_md_algo(int nid) -{ - switch (nid) { - case NID_gcrypt_nistp256: - return GCRY_MD_SHA256; - case NID_gcrypt_nistp384: - return GCRY_MD_SHA384; - case NID_gcrypt_nistp521: - return GCRY_MD_SHA512; - } - return GCRY_MD_NONE; -} - -void evp(int nid, unsigned char *digest, size_t len, - unsigned char *hash, unsigned int *hlen) -{ - int algo = nid_to_md_algo(nid); - - /* Note: What gcrypt calls 'hash' is called 'digest' here and - vice-versa. */ - gcry_md_hash_buffer(algo, hash, digest, len); - *hlen = gcry_md_get_algo_dlen(algo); -} - -EVPCTX evp_init(int nid) -{ - gcry_error_t err; - int algo = nid_to_md_algo(nid); - EVPCTX ctx; - - err = gcry_md_open(&ctx, algo, 0); - if (err) { - return NULL; - } - - return ctx; -} - -void evp_update(EVPCTX ctx, const void *data, size_t len) -{ - gcry_md_write(ctx, data, len); -} - -void evp_final(EVPCTX ctx, unsigned char *md, unsigned int *mdlen) -{ - int algo = gcry_md_get_algo(ctx); - *mdlen = gcry_md_get_algo_dlen(algo); - memcpy(md, gcry_md_read(ctx, algo), *mdlen); - gcry_md_close(ctx); -} -#endif - int ssh_kdf(struct ssh_crypto_struct *crypto, unsigned char *key, size_t key_len, uint8_t key_type, unsigned char *output, diff --git a/libssh/src/libmbedcrypto.c b/libssh/src/libmbedcrypto.c index 594e5369..caa3b6e9 100644 --- a/libssh/src/libmbedcrypto.c +++ b/libssh/src/libmbedcrypto.c @@ -51,80 +51,6 @@ void ssh_reseed(void) mbedtls_ctr_drbg_reseed(&ssh_mbedtls_ctr_drbg, NULL, 0); } -static mbedtls_md_type_t nid_to_md_algo(int nid) -{ - switch (nid) { - case NID_mbedtls_nistp256: - return MBEDTLS_MD_SHA256; - case NID_mbedtls_nistp384: - return MBEDTLS_MD_SHA384; - case NID_mbedtls_nistp521: - return MBEDTLS_MD_SHA512; - } - return MBEDTLS_MD_NONE; -} - -void evp(int nid, unsigned char *digest, size_t len, - unsigned char *hash, unsigned int *hlen) -{ - mbedtls_md_type_t algo = nid_to_md_algo(nid); - const mbedtls_md_info_t *md_info = - mbedtls_md_info_from_type(algo); - - - if (md_info != NULL) { - *hlen = mbedtls_md_get_size(md_info); - mbedtls_md(md_info, digest, len, hash); - } -} - -EVPCTX evp_init(int nid) -{ - EVPCTX ctx = NULL; - int rc; - mbedtls_md_type_t algo = nid_to_md_algo(nid); - const mbedtls_md_info_t *md_info = - mbedtls_md_info_from_type(algo); - - if (md_info == NULL) { - return NULL; - } - - ctx = malloc(sizeof(mbedtls_md_context_t)); - if (ctx == NULL) { - return NULL; - } - - mbedtls_md_init(ctx); - - rc = mbedtls_md_setup(ctx, md_info, 0); - if (rc != 0) { - SAFE_FREE(ctx); - return NULL; - } - - rc = mbedtls_md_starts(ctx); - if (rc != 0) { - SAFE_FREE(ctx); - return NULL; - } - - return ctx; -} - -void evp_update(EVPCTX ctx, const void *data, size_t len) -{ - mbedtls_md_update(ctx, data, len); -} - -void evp_final(EVPCTX ctx, unsigned char *md, unsigned int *mdlen) -{ - *mdlen = mbedtls_md_get_size(ctx->MBEDTLS_PRIVATE(md_info)); - mbedtls_md_finish(ctx, md); - mbedtls_md_free(ctx); - SAFE_FREE(ctx); -} - int ssh_kdf(struct ssh_crypto_struct *crypto, unsigned char *key, size_t key_len, uint8_t key_type, unsigned char *output, diff --git a/libssh/src/md_crypto.c b/libssh/src/md_crypto.c index f5104f04..f7cda8dd 100644 --- a/libssh/src/md_crypto.c +++ b/libssh/src/md_crypto.c @@ -25,6 +25,7 @@ #include "libssh/crypto.h" #include "libssh/wrapper.h" +#include #include #include #include @@ -46,28 +47,49 @@ sha1_init(void) } void +sha1_ctx_free(SHACTX c) +{ + EVP_MD_CTX_free(c); +} + +int sha1_update(SHACTX c, const void *data, size_t len) { - EVP_DigestUpdate(c, data, len); + int rc = EVP_DigestUpdate(c, data, len); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha1_final(unsigned char *md, SHACTX c) { unsigned int mdlen = 0; + int rc = EVP_DigestFinal(c, md, &mdlen); - EVP_DigestFinal(c, md, &mdlen); EVP_MD_CTX_free(c); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha1(const unsigned char *digest, size_t len, unsigned char *hash) { SHACTX c = sha1_init(); - if (c != NULL) { - sha1_update(c, digest, len); - sha1_final(hash, c); + int rc; + + if (c == NULL) { + return SSH_ERROR; } + rc = sha1_update(c, digest, len); + if (rc != SSH_OK) { + EVP_MD_CTX_free(c); + return SSH_ERROR; + } + return sha1_final(hash, c); } SHA256CTX @@ -87,28 +109,49 @@ sha256_init(void) } void +sha256_ctx_free(SHA256CTX c) +{ + EVP_MD_CTX_free(c); +} + +int sha256_update(SHA256CTX c, const void *data, size_t len) { - EVP_DigestUpdate(c, data, len); + int rc = EVP_DigestUpdate(c, data, len); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha256_final(unsigned char *md, SHA256CTX c) { unsigned int mdlen = 0; + int rc = EVP_DigestFinal(c, md, &mdlen); - EVP_DigestFinal(c, md, &mdlen); EVP_MD_CTX_free(c); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha256(const unsigned char *digest, size_t len, unsigned char *hash) { SHA256CTX c = sha256_init(); - if (c != NULL) { - sha256_update(c, digest, len); - sha256_final(hash, c); + int rc; + + if (c == NULL) { + return SSH_ERROR; + } + rc = sha256_update(c, digest, len); + if (rc != SSH_OK) { + EVP_MD_CTX_free(c); + return SSH_ERROR; } + return sha256_final(hash, c); } SHA384CTX @@ -128,28 +171,49 @@ sha384_init(void) } void +sha384_ctx_free(SHA384CTX c) +{ + EVP_MD_CTX_free(c); +} + +int sha384_update(SHA384CTX c, const void *data, size_t len) { - EVP_DigestUpdate(c, data, len); + int rc = EVP_DigestUpdate(c, data, len); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha384_final(unsigned char *md, SHA384CTX c) { unsigned int mdlen = 0; + int rc = EVP_DigestFinal(c, md, &mdlen); - EVP_DigestFinal(c, md, &mdlen); EVP_MD_CTX_free(c); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha384(const unsigned char *digest, size_t len, unsigned char *hash) { SHA384CTX c = sha384_init(); - if (c != NULL) { - sha384_update(c, digest, len); - sha384_final(hash, c); + int rc; + + if (c == NULL) { + return SSH_ERROR; } + rc = sha384_update(c, digest, len); + if (rc != SSH_OK) { + EVP_MD_CTX_free(c); + return SSH_ERROR; + } + return sha384_final(hash, c); } SHA512CTX @@ -169,28 +233,49 @@ sha512_init(void) } void +sha512_ctx_free(SHA512CTX c) +{ + EVP_MD_CTX_free(c); +} + +int sha512_update(SHA512CTX c, const void *data, size_t len) { - EVP_DigestUpdate(c, data, len); + int rc = EVP_DigestUpdate(c, data, len); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha512_final(unsigned char *md, SHA512CTX c) { unsigned int mdlen = 0; + int rc = EVP_DigestFinal(c, md, &mdlen); - EVP_DigestFinal(c, md, &mdlen); EVP_MD_CTX_free(c); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha512(const unsigned char *digest, size_t len, unsigned char *hash) { SHA512CTX c = sha512_init(); - if (c != NULL) { - sha512_update(c, digest, len); - sha512_final(hash, c); + int rc; + + if (c == NULL) { + return SSH_ERROR; + } + rc = sha512_update(c, digest, len); + if (rc != SSH_OK) { + EVP_MD_CTX_free(c); + return SSH_ERROR; } + return sha512_final(hash, c); } MD5CTX @@ -210,16 +295,30 @@ md5_init(void) } void +md5_ctx_free(MD5CTX c) +{ + EVP_MD_CTX_free(c); +} + +int md5_update(MD5CTX c, const void *data, size_t len) { - EVP_DigestUpdate(c, data, len); + int rc = EVP_DigestUpdate(c, data, len); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } -void +int md5_final(unsigned char *md, MD5CTX c) { unsigned int mdlen = 0; + int rc = EVP_DigestFinal(c, md, &mdlen); - EVP_DigestFinal(c, md, &mdlen); EVP_MD_CTX_free(c); + if (rc != 1) { + return SSH_ERROR; + } + return SSH_OK; } diff --git a/libssh/src/md_gcrypt.c b/libssh/src/md_gcrypt.c index 1f0a71f3..93c7b0d9 100644 --- a/libssh/src/md_gcrypt.c +++ b/libssh/src/md_gcrypt.c @@ -36,24 +36,40 @@ sha1_init(void) return ctx; } -void +int sha1_update(SHACTX c, const void *data, size_t len) { gcry_md_write(c, data, len); + return SSH_OK; } void +sha1_ctx_free(SHACTX c) +{ + gcry_md_close(c); +} + +int sha1_final(unsigned char *md, SHACTX c) { + unsigned char *tmp = NULL; + gcry_md_final(c); - memcpy(md, gcry_md_read(c, 0), SHA_DIGEST_LEN); + tmp = gcry_md_read(c, 0); + if (tmp == NULL) { + gcry_md_close(c); + return SSH_ERROR; + } + memcpy(md, tmp, SHA_DIGEST_LEN); gcry_md_close(c); + return SSH_OK; } -void +int sha1(const unsigned char *digest, size_t len, unsigned char *hash) { gcry_md_hash_buffer(GCRY_MD_SHA1, hash, digest, len); + return SSH_OK; } SHA256CTX @@ -66,23 +82,39 @@ sha256_init(void) } void +sha256_ctx_free(SHA256CTX c) +{ + gcry_md_close(c); +} + +int sha256_update(SHACTX c, const void *data, size_t len) { gcry_md_write(c, data, len); + return SSH_OK; } -void +int sha256_final(unsigned char *md, SHACTX c) { + unsigned char *tmp = NULL; + gcry_md_final(c); - memcpy(md, gcry_md_read(c, 0), SHA256_DIGEST_LEN); + tmp = gcry_md_read(c, 0); + if (tmp == NULL) { + gcry_md_close(c); + return SSH_ERROR; + } + memcpy(md, tmp, SHA256_DIGEST_LEN); gcry_md_close(c); + return SSH_OK; } -void +int sha256(const unsigned char *digest, size_t len, unsigned char *hash) { gcry_md_hash_buffer(GCRY_MD_SHA256, hash, digest, len); + return SSH_OK; } SHA384CTX @@ -95,23 +127,39 @@ sha384_init(void) } void +sha384_ctx_free(SHA384CTX c) +{ + gcry_md_close(c); +} + +int sha384_update(SHACTX c, const void *data, size_t len) { gcry_md_write(c, data, len); + return SSH_OK; } -void +int sha384_final(unsigned char *md, SHACTX c) { + unsigned char *tmp = NULL; + gcry_md_final(c); - memcpy(md, gcry_md_read(c, 0), SHA384_DIGEST_LEN); + tmp = gcry_md_read(c, 0); + if (tmp == NULL) { + gcry_md_close(c); + return SSH_ERROR; + } + memcpy(md, tmp, SHA384_DIGEST_LEN); gcry_md_close(c); + return SSH_OK; } -void +int sha384(const unsigned char *digest, size_t len, unsigned char *hash) { gcry_md_hash_buffer(GCRY_MD_SHA384, hash, digest, len); + return SSH_OK; } SHA512CTX @@ -124,23 +172,39 @@ sha512_init(void) } void +sha512_ctx_free(SHA512CTX c) +{ + gcry_md_close(c); +} + +int sha512_update(SHACTX c, const void *data, size_t len) { gcry_md_write(c, data, len); + return SSH_OK; } -void +int sha512_final(unsigned char *md, SHACTX c) { + unsigned char *tmp = NULL; + gcry_md_final(c); - memcpy(md, gcry_md_read(c, 0), SHA512_DIGEST_LEN); + tmp = gcry_md_read(c, 0); + if (tmp == NULL) { + gcry_md_close(c); + return SSH_ERROR; + } + memcpy(md, tmp, SHA512_DIGEST_LEN); gcry_md_close(c); + return SSH_OK; } -void +int sha512(const unsigned char *digest, size_t len, unsigned char *hash) { gcry_md_hash_buffer(GCRY_MD_SHA512, hash, digest, len); + return SSH_OK; } MD5CTX @@ -153,15 +217,30 @@ md5_init(void) } void +md5_ctx_free(MD5CTX c) +{ + gcry_md_close(c); +} + +int md5_update(MD5CTX c, const void *data, size_t len) { gcry_md_write(c, data, len); + return SSH_OK; } -void +int md5_final(unsigned char *md, MD5CTX c) { + unsigned char *tmp = NULL; + gcry_md_final(c); - memcpy(md, gcry_md_read(c, 0), MD5_DIGEST_LEN); + tmp = gcry_md_read(c, 0); + if (tmp == NULL) { + gcry_md_close(c); + return SSH_ERROR; + } + memcpy(md, tmp, MD5_DIGEST_LEN); gcry_md_close(c); + return SSH_OK; } diff --git a/libssh/src/md_mbedcrypto.c b/libssh/src/md_mbedcrypto.c index 227e20ab..b3529b4b 100644 --- a/libssh/src/md_mbedcrypto.c +++ b/libssh/src/md_mbedcrypto.c @@ -64,27 +64,48 @@ sha1_init(void) } void +sha1_ctx_free(SHACTX c) +{ + mbedtls_md_free(c); + SAFE_FREE(c); +} + +int sha1_update(SHACTX c, const void *data, size_t len) { - mbedtls_md_update(c, data, len); + int rc = mbedtls_md_update(c, data, len); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha1_final(unsigned char *md, SHACTX c) { - mbedtls_md_finish(c, md); - mbedtls_md_free(c); - SAFE_FREE(c); + int rc = mbedtls_md_finish(c, md); + sha1_ctx_free(c); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha1(const unsigned char *digest, size_t len, unsigned char *hash) { const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1); - if (md_info != NULL) { - mbedtls_md(md_info, digest, len, hash); + int rc; + + if (md_info == NULL) { + return SSH_ERROR; + } + rc = mbedtls_md(md_info, digest, len, hash); + if (rc != 0) { + return SSH_ERROR; } + return SSH_OK; } SHA256CTX @@ -122,27 +143,48 @@ sha256_init(void) } void +sha256_ctx_free(SHA256CTX c) +{ + mbedtls_md_free(c); + SAFE_FREE(c); +} + +int sha256_update(SHA256CTX c, const void *data, size_t len) { - mbedtls_md_update(c, data, len); + int rc = mbedtls_md_update(c, data, len); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha256_final(unsigned char *md, SHA256CTX c) { - mbedtls_md_finish(c, md); + int rc = mbedtls_md_finish(c, md); mbedtls_md_free(c); SAFE_FREE(c); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha256(const unsigned char *digest, size_t len, unsigned char *hash) { + int rc; const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); - if (md_info != NULL) { - mbedtls_md(md_info, digest, len, hash); + if (md_info == NULL) { + return SSH_ERROR; + } + rc = mbedtls_md(md_info, digest, len, hash); + if (rc != 0) { + return SSH_ERROR; } + return SSH_OK; } SHA384CTX @@ -180,27 +222,48 @@ sha384_init(void) } void +sha384_ctx_free(SHA384CTX c) +{ + mbedtls_md_free(c); + SAFE_FREE(c); +} + +int sha384_update(SHA384CTX c, const void *data, size_t len) { - mbedtls_md_update(c, data, len); + int rc = mbedtls_md_update(c, data, len); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha384_final(unsigned char *md, SHA384CTX c) { - mbedtls_md_finish(c, md); - mbedtls_md_free(c); - SAFE_FREE(c); + int rc = mbedtls_md_finish(c, md); + sha384_ctx_free(c); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha384(const unsigned char *digest, size_t len, unsigned char *hash) { const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA384); - if (md_info != NULL) { - mbedtls_md(md_info, digest, len, hash); + int rc; + + if (md_info == NULL) { + return SSH_ERROR; + } + rc = mbedtls_md(md_info, digest, len, hash); + if (rc != 0) { + return SSH_ERROR; } + return SSH_OK; } SHA512CTX @@ -237,27 +300,48 @@ sha512_init(void) } void +sha512_ctx_free(SHA512CTX c) +{ + mbedtls_md_free(c); + SAFE_FREE(c); +} + +int sha512_update(SHA512CTX c, const void *data, size_t len) { - mbedtls_md_update(c, data, len); + int rc = mbedtls_md_update(c, data, len); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha512_final(unsigned char *md, SHA512CTX c) { - mbedtls_md_finish(c, md); - mbedtls_md_free(c); - SAFE_FREE(c); + int rc = mbedtls_md_finish(c, md); + sha512_ctx_free(c); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int sha512(const unsigned char *digest, size_t len, unsigned char *hash) { const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA512); - if (md_info != NULL) { - mbedtls_md(md_info, digest, len, hash); + int rc; + + if (md_info == NULL) { + return SSH_ERROR; } + rc = mbedtls_md(md_info, digest, len, hash); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } MD5CTX @@ -294,15 +378,30 @@ md5_init(void) } void +md5_ctx_free(MD5CTX c) +{ + mbedtls_md_free(c); + SAFE_FREE(c); +} + +int md5_update(MD5CTX c, const void *data, size_t len) { - mbedtls_md_update(c, data, len); + int rc = mbedtls_md_update(c, data, len); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } -void +int md5_final(unsigned char *md, MD5CTX c) { - mbedtls_md_finish(c, md); + int rc = mbedtls_md_finish(c, md); mbedtls_md_free(c); SAFE_FREE(c); + if (rc != 0) { + return SSH_ERROR; + } + return SSH_OK; } diff --git a/libssh/src/misc.c b/libssh/src/misc.c index 7c478a77..7081f12a 100644 --- a/libssh/src/misc.c +++ b/libssh/src/misc.c @@ -32,6 +32,7 @@ #include #include #include +#include #endif /* _WIN32 */ @@ -59,6 +60,7 @@ #include #include #include +#include #ifdef HAVE_IO_H #include @@ -94,6 +96,8 @@ #define ZLIB_STRING "" #endif +#define ARPA_DOMAIN_MAX_LEN 63 + /** * @defgroup libssh_misc The SSH helper functions * @ingroup libssh @@ -220,22 +224,37 @@ int ssh_is_ipaddr_v4(const char *str) int ssh_is_ipaddr(const char *str) { int rc = SOCKET_ERROR; + char *s = strdup(str); - if (strchr(str, ':')) { + if (s == NULL) { + return -1; + } + if (strchr(s, ':')) { struct sockaddr_storage ss; int sslen = sizeof(ss); - - /* TODO link-local (IP:v6:addr%ifname). */ - rc = WSAStringToAddressA((LPSTR) str, + char *network_interface = strchr(s, '%'); + + /* link-local (IP:v6:addr%ifname). */ + if (network_interface != NULL) { + rc = if_nametoindex(network_interface + 1); + if (rc == 0) { + free(s); + return 0; + } + *network_interface = '\0'; + } + rc = WSAStringToAddressA((LPSTR) s, AF_INET6, NULL, (struct sockaddr*)&ss, &sslen); if (rc == 0) { + free(s); return 1; } } + free(s); return ssh_is_ipaddr_v4(str); } #else /* _WIN32 */ @@ -341,17 +360,32 @@ int ssh_is_ipaddr_v4(const char *str) int ssh_is_ipaddr(const char *str) { int rc = -1; + char *s = strdup(str); - if (strchr(str, ':')) { + if (s == NULL) { + return -1; + } + if (strchr(s, ':')) { struct in6_addr dest6; - - /* TODO link-local (IP:v6:addr%ifname). */ - rc = inet_pton(AF_INET6, str, &dest6); + char *network_interface = strchr(s, '%'); + + /* link-local (IP:v6:addr%ifname). */ + if (network_interface != NULL) { + rc = if_nametoindex(network_interface + 1); + if (rc == 0) { + free(s); + return 0; + } + *network_interface = '\0'; + } + rc = inet_pton(AF_INET6, s, &dest6); if (rc > 0) { + free(s); return 1; } } + free(s); return ssh_is_ipaddr_v4(str); } @@ -1974,4 +2008,70 @@ char *ssh_strerror(int err_num, char *buf, size_t buflen) #endif /* defined(__linux__) && defined(__GLIBC__) && defined(_GNU_SOURCE) */ } +/** + * @brief Checks syntax of a domain name + * + * The check is made based on the RFC1035 section 2.3.1 + * Allowed characters are: hyphen, period, digits (0-9) and letters (a-zA-Z) + * + * The label should be no longer than 63 characters + * The label should start with a letter and end with a letter or number + * The label in this implementation can start with a number to allow virtual + * URLs to pass. Note that this will make IPv4 addresses to pass + * this check too. + * + * @param hostname The domain name to be checked, has to be null terminated + * + * @return SSH_OK if the hostname passes syntax check + * SSH_ERROR otherwise or if hostname is NULL or empty string + */ +int ssh_check_hostname_syntax(const char *hostname) +{ + char *it = NULL, *s = NULL, *buf = NULL; + size_t it_len; + char c; + + if (hostname == NULL || strlen(hostname) == 0) { + return SSH_ERROR; + } + + /* strtok_r writes into the string, keep the input clean */ + s = strdup(hostname); + if (s == NULL) { + return SSH_ERROR; + } + + it = strtok_r(s, ".", &buf); + /* if the token has 0 length */ + if (it == NULL) { + free(s); + return SSH_ERROR; + } + do { + it_len = strlen(it); + if (it_len > ARPA_DOMAIN_MAX_LEN || + /* the first char must be a letter, but some virtual urls start + * with a number */ + isalnum(it[0]) == 0 || + isalnum(it[it_len - 1]) == 0) { + free(s); + return SSH_ERROR; + } + while (*it != '\0') { + c = *it; + /* the "." is allowed too, but tokenization removes it from the + * string */ + if (isalnum(c) == 0 && c != '-') { + free(s); + return SSH_ERROR; + } + it++; + } + } while ((it = strtok_r(NULL, ".", &buf)) != NULL); + + free(s); + + return SSH_OK; +} + /** @} */ diff --git a/libssh/src/options.c b/libssh/src/options.c index 6f2c9397..b3ecffe1 100644 --- a/libssh/src/options.c +++ b/libssh/src/options.c @@ -37,6 +37,7 @@ #include "libssh/session.h" #include "libssh/misc.h" #include "libssh/options.h" +#include "libssh/config_parser.h" #ifdef WITH_SERVER #include "libssh/server.h" #include "libssh/bind.h" @@ -515,33 +516,18 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type, ssh_set_error_invalid(session); return -1; } else { - q = strdup(value); - if (q == NULL) { - ssh_set_error_oom(session); + char *username = NULL, *hostname = NULL; + rc = ssh_config_parse_uri(value, &username, &hostname, NULL, true); + if (rc != SSH_OK) { return -1; } - p = strrchr(q, '@'); - - SAFE_FREE(session->opts.host); - - if (p) { - *p = '\0'; - session->opts.host = strdup(p + 1); - if (session->opts.host == NULL) { - SAFE_FREE(q); - ssh_set_error_oom(session); - return -1; - } - + if (username != NULL) { SAFE_FREE(session->opts.username); - session->opts.username = strdup(q); - SAFE_FREE(q); - if (session->opts.username == NULL) { - ssh_set_error_oom(session); - return -1; - } - } else { - session->opts.host = q; + session->opts.username = username; + } + if (hostname != NULL) { + SAFE_FREE(session->opts.host); + session->opts.host = hostname; } } break; diff --git a/libssh/src/packet.c b/libssh/src/packet.c index eb7eb42a..ea73f9ad 100644 --- a/libssh/src/packet.c +++ b/libssh/src/packet.c @@ -1314,6 +1314,19 @@ ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user) } #endif /* WITH_ZLIB */ payloadsize = ssh_buffer_get_len(session->in_buffer); + if (session->recv_seq == UINT32_MAX) { + /* Overflowing sequence numbers is always fishy */ + if (crypto == NULL) { + /* don't allow sequence number overflow when unencrypted */ + ssh_set_error(session, + SSH_FATAL, + "Incoming sequence number overflow"); + goto error; + } else { + SSH_LOG(SSH_LOG_WARNING, + "Incoming sequence number overflow"); + } + } session->recv_seq++; if (crypto != NULL) { struct ssh_cipher_struct *cipher = NULL; @@ -1338,7 +1351,19 @@ ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user) "comp=%" PRIu32 ",payload=%" PRIu32 "]", session->in_packet.type, packet_len, padding, compsize, payloadsize); + if (crypto == NULL) { + /* In strict kex, only a few packets are allowed. Taint the session + * if we received packets that are normally allowed but to be + * refused if we are in strict kex when KEX is over. + */ + uint8_t type = session->in_packet.type; + if (type != SSH2_MSG_KEXINIT && type != SSH2_MSG_NEWKEYS && + (type < SSH2_MSG_KEXDH_INIT || + type > SSH2_MSG_KEX_DH_GEX_REQUEST)) { + session->flags |= SSH_SESSION_FLAG_KEX_TAINTED; + } + } /* Check if the packet is expected */ filter_result = ssh_packet_incoming_filter(session); @@ -1354,6 +1379,9 @@ ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user) session->in_packet.type); goto error; case SSH_PACKET_UNKNOWN: + if (crypto == NULL) { + session->flags |= SSH_SESSION_FLAG_KEX_TAINTED; + } ssh_packet_send_unimplemented(session, session->recv_seq - 1); break; } @@ -1529,7 +1557,33 @@ void ssh_packet_process(ssh_session session, uint8_t type) SSH_LOG(SSH_LOG_RARE, "Failed to send unimplemented: %s", ssh_get_error(session)); } + if (session->current_crypto == NULL) { + session->flags |= SSH_SESSION_FLAG_KEX_TAINTED; + } + } +} + +/** @internal + * @brief sends a SSH_MSG_NEWKEYS when enabling the new negotiated ciphers + * @param session the SSH session + * @return SSH_ERROR on error, else SSH_OK + */ +int ssh_packet_send_newkeys(ssh_session session) +{ + int rc; + + /* Send the MSG_NEWKEYS */ + rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS); + if (rc < 0) { + return rc; } + + rc = ssh_packet_send(session); + if (rc == SSH_ERROR) { + return rc; + } + SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent"); + return rc; } /** @internal @@ -1842,6 +1896,10 @@ int ssh_packet_send(ssh_session session) if (rc == SSH_OK && type == SSH2_MSG_NEWKEYS) { struct ssh_iterator *it; + if (session->flags & SSH_SESSION_FLAG_KEX_STRICT) { + /* reset packet sequence number when running in strict kex mode */ + session->send_seq = 0; + } for (it = ssh_list_get_iterator(session->out_queue); it != NULL; it = ssh_list_get_iterator(session->out_queue)) { diff --git a/libssh/src/packet_cb.c b/libssh/src/packet_cb.c index 0ecf8771..2f364c26 100644 --- a/libssh/src/packet_cb.c +++ b/libssh/src/packet_cb.c @@ -115,6 +115,18 @@ SSH_PACKET_CALLBACK(ssh_packet_newkeys){ goto error; } + if (session->flags & SSH_SESSION_FLAG_KEX_STRICT) { + /* reset packet sequence number when running in strict kex mode */ + session->recv_seq = 0; + /* Check that we aren't tainted */ + if (session->flags & SSH_SESSION_FLAG_KEX_TAINTED) { + ssh_set_error(session, + SSH_FATAL, + "Received unexpected packets in strict KEX mode."); + goto error; + } + } + if(session->server){ /* server things are done in server.c */ session->dh_handshake_state=DH_STATE_FINISHED; diff --git a/libssh/src/poll.c b/libssh/src/poll.c index 828f5e0a..8f81c11c 100644 --- a/libssh/src/poll.c +++ b/libssh/src/poll.c @@ -698,13 +698,13 @@ int ssh_poll_ctx_dopoll(ssh_poll_ctx ctx, int timeout) return SSH_ERROR; } - /* Ignore any pollin events on locked sockets as that means we are called + /* Allow only POLLOUT events on locked sockets as that means we are called * recursively and we only want process the POLLOUT events here to flush * output buffer */ for (i = 0; i < ctx->polls_used; i++) { - /* The lock prevents invoking POLLIN events: drop them now */ + /* The lock allows only POLLOUT events: drop the rest */ if (ctx->pollptrs[i]->lock_cnt > 0) { - ctx->pollfds[i].events &= ~POLLIN; + ctx->pollfds[i].events &= POLLOUT; } } ssh_timestamp_init(&ts); @@ -722,14 +722,21 @@ int ssh_poll_ctx_dopoll(ssh_poll_ctx ctx, int timeout) used = ctx->polls_used; for (i = 0; i < used && rc > 0; ) { - if (ctx->pollfds[i].revents == 0) { + revents = ctx->pollfds[i].revents; + /* Do not pass any other events except for POLLOUT to callback when + * called recursively more than 2 times. On s390x the poll will be + * spammed with POLLHUP events causing infinite recursion when the user + * callback issues some write/flush/poll calls. */ + if (ctx->pollptrs[i]->lock_cnt > 2) { + revents &= POLLOUT; + } + if (revents == 0) { i++; } else { int ret; p = ctx->pollptrs[i]; fd = ctx->pollfds[i].fd; - revents = ctx->pollfds[i].revents; /* avoid having any event caught during callback */ ctx->pollfds[i].events = 0; p->lock_cnt++; diff --git a/libssh/src/server.c b/libssh/src/server.c index b978fc17..70b90899 100644 --- a/libssh/src/server.c +++ b/libssh/src/server.c @@ -195,7 +195,13 @@ int server_set_kex(ssh_session session) } } - return 0; + /* Do not append the extensions during rekey */ + if (session->flags & SSH_SESSION_FLAG_AUTHENTICATED) { + return SSH_OK; + } + + rc = ssh_kex_append_extensions(session, server); + return rc; } int ssh_server_init_kex(ssh_session session) { @@ -544,9 +550,10 @@ int ssh_send_issue_banner(ssh_session session, const ssh_string banner) "Sending a server issue banner"); rc = ssh_buffer_pack(session->out_buffer, - "bS", + "bSs", SSH2_MSG_USERAUTH_BANNER, - banner); + banner, + ""); if (rc != SSH_OK) { ssh_set_error_oom(session); return SSH_ERROR; diff --git a/libssh/src/session.c b/libssh/src/session.c index 0fb758ce..8c509699 100644 --- a/libssh/src/session.c +++ b/libssh/src/session.c @@ -663,6 +663,10 @@ int ssh_handle_packets(ssh_session session, int timeout) } spoll = ssh_socket_get_poll_handle(session->socket); + if (spoll == NULL) { + ssh_set_error_oom(session); + return SSH_ERROR; + } ssh_poll_add_events(spoll, POLLIN); ctx = ssh_poll_get_ctx(spoll); @@ -1020,7 +1024,18 @@ int ssh_get_pubkey_hash(ssh_session session, unsigned char **hash) *hash = NULL; if (session->current_crypto == NULL || session->current_crypto->server_pubkey == NULL) { - ssh_set_error(session,SSH_FATAL,"No current cryptographic context"); + ssh_set_error(session, SSH_FATAL, "No current cryptographic context"); + return SSH_ERROR; + } + + rc = ssh_get_server_publickey(session, &pubkey); + if (rc != SSH_OK) { + return SSH_ERROR; + } + + rc = ssh_pki_export_pubkey_blob(pubkey, &pubkey_blob); + ssh_key_free(pubkey); + if (rc != SSH_OK) { return SSH_ERROR; } @@ -1035,25 +1050,21 @@ int ssh_get_pubkey_hash(ssh_session session, unsigned char **hash) return SSH_ERROR; } - rc = ssh_get_server_publickey(session, &pubkey); + rc = md5_update(ctx, + ssh_string_data(pubkey_blob), + ssh_string_len(pubkey_blob)); if (rc != SSH_OK) { - md5_final(h, ctx); + md5_ctx_free(ctx); SAFE_FREE(h); - return SSH_ERROR; + return rc; } - - rc = ssh_pki_export_pubkey_blob(pubkey, &pubkey_blob); - ssh_key_free(pubkey); + SSH_STRING_FREE(pubkey_blob); + rc = md5_final(h, ctx); if (rc != SSH_OK) { - md5_final(h, ctx); SAFE_FREE(h); - return SSH_ERROR; + return rc; } - md5_update(ctx, ssh_string_data(pubkey_blob), ssh_string_len(pubkey_blob)); - SSH_STRING_FREE(pubkey_blob); - md5_final(h, ctx); - *hash = h; return MD5_DIGEST_LEN; @@ -1173,8 +1184,17 @@ int ssh_get_publickey_hash(const ssh_key key, goto out; } - sha1_update(ctx, ssh_string_data(blob), ssh_string_len(blob)); - sha1_final(h, ctx); + rc = sha1_update(ctx, ssh_string_data(blob), ssh_string_len(blob)); + if (rc != SSH_OK) { + free(h); + sha1_ctx_free(ctx); + goto out; + } + rc = sha1_final(h, ctx); + if (rc != SSH_OK) { + free(h); + goto out; + } *hlen = SHA_DIGEST_LEN; } @@ -1196,8 +1216,17 @@ int ssh_get_publickey_hash(const ssh_key key, goto out; } - sha256_update(ctx, ssh_string_data(blob), ssh_string_len(blob)); - sha256_final(h, ctx); + rc = sha256_update(ctx, ssh_string_data(blob), ssh_string_len(blob)); + if (rc != SSH_OK) { + free(h); + sha256_ctx_free(ctx); + goto out; + } + rc = sha256_final(h, ctx); + if (rc != SSH_OK) { + free(h); + goto out; + } *hlen = SHA256_DIGEST_LEN; } @@ -1227,8 +1256,17 @@ int ssh_get_publickey_hash(const ssh_key key, goto out; } - md5_update(ctx, ssh_string_data(blob), ssh_string_len(blob)); - md5_final(h, ctx); + rc = md5_update(ctx, ssh_string_data(blob), ssh_string_len(blob)); + if (rc != SSH_OK) { + free(h); + md5_ctx_free(ctx); + goto out; + } + rc = md5_final(h, ctx); + if (rc != SSH_OK) { + free(h); + goto out; + } *hlen = MD5_DIGEST_LEN; } diff --git a/libssh/tests/CMakeLists.txt b/libssh/tests/CMakeLists.txt index 09b96100..f5c30061 100644 --- a/libssh/tests/CMakeLists.txt +++ b/libssh/tests/CMakeLists.txt @@ -165,6 +165,7 @@ if (CLIENT_TESTING OR SERVER_TESTING) find_package(nss_wrapper 1.1.2 REQUIRED) find_package(uid_wrapper 1.2.0 REQUIRED) find_package(pam_wrapper 1.0.1 REQUIRED) + find_package(priv_wrapper 1.0.0) if (NOT SSHD_EXECUTABLE) message(SEND_ERROR "Could not find sshd which is required for client testing") @@ -212,13 +213,18 @@ if (CLIENT_TESTING OR SERVER_TESTING) set(WITH_TIMEOUT "1") endif() - # chroot_wrapper - add_library(chroot_wrapper SHARED chroot_wrapper.c) - set(CHROOT_WRAPPER_LIBRARY ${libssh_BINARY_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}chroot_wrapper${CMAKE_SHARED_LIBRARY_SUFFIX}) - set(TEST_TARGET_LIBRARIES - ${TEST_TARGET_LIBRARIES} - chroot_wrapper - ) + # For chroot() use priv_wrapper package if found, or internal chroot_wrapper + if (priv_wrapper_FOUND) + set(CHROOT_WRAPPER "${PRIV_WRAPPER_LIBRARY}") + else() + add_library(chroot_wrapper SHARED chroot_wrapper.c) + set(CHROOT_WRAPPER_LIBRARY ${libssh_BINARY_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}chroot_wrapper${CMAKE_SHARED_LIBRARY_SUFFIX}) + set(TEST_TARGET_LIBRARIES + ${TEST_TARGET_LIBRARIES} + chroot_wrapper + ) + set(CHROOT_WRAPPER "${CHROOT_WRAPPER_LIBRARY}") + endif() # ssh_ping add_executable(ssh_ping ssh_ping.c) @@ -239,7 +245,10 @@ if (CLIENT_TESTING OR SERVER_TESTING) configure_file(etc/pam.d/sshd.in ${CMAKE_CURRENT_BINARY_DIR}/etc/pam.d/sshd @ONLY) - set(TORTURE_ENVIRONMENT "LD_PRELOAD=${SOCKET_WRAPPER_LIBRARY}:${NSS_WRAPPER_LIBRARY}:${UID_WRAPPER_LIBRARY}:${PAM_WRAPPER_LIBRARY}:${CHROOT_WRAPPER_LIBRARY}") + set(TORTURE_ENVIRONMENT "LD_PRELOAD=${SOCKET_WRAPPER_LIBRARY}:${NSS_WRAPPER_LIBRARY}:${UID_WRAPPER_LIBRARY}:${PAM_WRAPPER_LIBRARY}:${CHROOT_WRAPPER}") + if (priv_wrapper_FOUND) + list(APPEND TORTURE_ENVIRONMENT PRIV_WRAPPER=1 PRIV_WRAPPER_CHROOT_DISABLE=1) + endif() list(APPEND TORTURE_ENVIRONMENT UID_WRAPPER=1 UID_WRAPPER_ROOT=1) list(APPEND TORTURE_ENVIRONMENT NSS_WRAPPER_PASSWD=${CMAKE_CURRENT_BINARY_DIR}/etc/passwd) list(APPEND TORTURE_ENVIRONMENT NSS_WRAPPER_SHADOW=${CMAKE_CURRENT_BINARY_DIR}/etc/shadow) diff --git a/libssh/tests/client/torture_proxycommand.c b/libssh/tests/client/torture_proxycommand.c index 9b8019ca..1bad4ccc 100644 --- a/libssh/tests/client/torture_proxycommand.c +++ b/libssh/tests/client/torture_proxycommand.c @@ -166,6 +166,56 @@ static void torture_options_set_proxycommand_ssh_stderr(void **state) assert_int_equal(rc & O_RDWR, O_RDWR); } +static void torture_options_proxycommand_injection(void **state) +{ + struct torture_state *s = *state; + struct passwd *pwd = NULL; + const char *malicious_host = "`echo foo > mfile`"; + const char *command = "nc %h %p"; + char *current_dir = NULL; + char *malicious_file_path = NULL; + int mfp_len; + int verbosity = torture_libssh_verbosity(); + struct stat sb; + int rc; + + pwd = getpwnam("bob"); + assert_non_null(pwd); + + rc = setuid(pwd->pw_uid); + assert_return_code(rc, errno); + + s->ssh.session = ssh_new(); + assert_non_null(s->ssh.session); + + ssh_options_set(s->ssh.session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity); + // if we would be checking the rc, this should fail + ssh_options_set(s->ssh.session, SSH_OPTIONS_HOST, malicious_host); + + ssh_options_set(s->ssh.session, SSH_OPTIONS_USER, TORTURE_SSH_USER_ALICE); + + rc = ssh_options_set(s->ssh.session, SSH_OPTIONS_PROXYCOMMAND, command); + assert_int_equal(rc, 0); + rc = ssh_connect(s->ssh.session); + assert_ssh_return_code_equal(s->ssh.session, rc, SSH_ERROR); + + current_dir = torture_get_current_working_dir(); + assert_non_null(current_dir); + mfp_len = strlen(current_dir) + 6; + malicious_file_path = malloc(mfp_len); + assert_non_null(malicious_file_path); + rc = snprintf(malicious_file_path, mfp_len, + "%s/mfile", current_dir); + assert_int_equal(rc, mfp_len); + free(current_dir); + rc = stat(malicious_file_path, &sb); + assert_int_not_equal(rc, 0); + + // cleanup + remove(malicious_file_path); + free(malicious_file_path); +} + int torture_run_tests(void) { int rc; struct CMUnitTest tests[] = { @@ -181,6 +231,9 @@ int torture_run_tests(void) { cmocka_unit_test_setup_teardown(torture_options_set_proxycommand_ssh_stderr, session_setup, session_teardown), + cmocka_unit_test_setup_teardown(torture_options_proxycommand_injection, + NULL, + session_teardown), }; diff --git a/libssh/tests/client/torture_rekey.c b/libssh/tests/client/torture_rekey.c index ccd5ae2c..57e03e3f 100644 --- a/libssh/tests/client/torture_rekey.c +++ b/libssh/tests/client/torture_rekey.c @@ -148,6 +148,29 @@ static void torture_rekey_default(void **state) ssh_disconnect(s->ssh.session); } +static void sanity_check_session(void **state) +{ + struct torture_state *s = *state; + struct ssh_crypto_struct *c = NULL; + + c = s->ssh.session->current_crypto; + assert_non_null(c); + assert_int_equal(c->in_cipher->max_blocks, + bytes / c->in_cipher->blocksize); + assert_int_equal(c->out_cipher->max_blocks, + bytes / c->out_cipher->blocksize); + /* when strict kex is used, the newkeys reset the sequence number */ + if ((s->ssh.session->flags & SSH_SESSION_FLAG_KEX_STRICT) != 0) { + assert_int_equal(c->out_cipher->packets, s->ssh.session->send_seq); + assert_int_equal(c->in_cipher->packets, s->ssh.session->recv_seq); + } else { + /* Otherwise we have less encrypted packets than transferred + * (first are not encrypted) */ + assert_true(c->out_cipher->packets < s->ssh.session->send_seq); + assert_true(c->in_cipher->packets < s->ssh.session->recv_seq); + } +} + /* We lower the rekey limits manually and check that the rekey * really happens when sending data */ @@ -166,16 +189,10 @@ static void torture_rekey_send(void **state) rc = ssh_connect(s->ssh.session); assert_ssh_return_code(s->ssh.session, rc); - /* The blocks limit is set correctly */ - c = s->ssh.session->current_crypto; - assert_int_equal(c->in_cipher->max_blocks, - bytes / c->in_cipher->blocksize); - assert_int_equal(c->out_cipher->max_blocks, - bytes / c->out_cipher->blocksize); - /* We should have less encrypted packets than transferred (first are not encrypted) */ - assert_true(c->out_cipher->packets < s->ssh.session->send_seq); - assert_true(c->in_cipher->packets < s->ssh.session->recv_seq); + sanity_check_session(state); /* Copy the initial secret hash = session_id so we know we changed keys later */ + c = s->ssh.session->current_crypto; + assert_non_null(c); secret_hash = malloc(c->digest_len); assert_non_null(secret_hash); memcpy(secret_hash, c->secret_hash, c->digest_len); @@ -273,15 +290,10 @@ static void torture_rekey_recv(void **state) mode_t mask; int rc; - /* The blocks limit is set correctly */ + sanity_check_session(state); + /* Copy the initial secret hash = session_id so we know we changed keys later */ c = s->ssh.session->current_crypto; assert_non_null(c); - assert_int_equal(c->in_cipher->max_blocks, bytes / c->in_cipher->blocksize); - assert_int_equal(c->out_cipher->max_blocks, bytes / c->out_cipher->blocksize); - /* We should have less encrypted packets than transferred (first are not encrypted) */ - assert_true(c->out_cipher->packets < s->ssh.session->send_seq); - assert_true(c->in_cipher->packets < s->ssh.session->recv_seq); - /* Copy the initial secret hash = session_id so we know we changed keys later */ secret_hash = malloc(c->digest_len); assert_non_null(secret_hash); memcpy(secret_hash, c->secret_hash, c->digest_len); @@ -468,15 +480,10 @@ static void torture_rekey_different_kex(void **state) assert_ssh_return_code(s->ssh.session, rc); /* The blocks limit is set correctly */ - c = s->ssh.session->current_crypto; - assert_int_equal(c->in_cipher->max_blocks, - bytes / c->in_cipher->blocksize); - assert_int_equal(c->out_cipher->max_blocks, - bytes / c->out_cipher->blocksize); - /* We should have less encrypted packets than transferred (first are not encrypted) */ - assert_true(c->out_cipher->packets < s->ssh.session->send_seq); - assert_true(c->in_cipher->packets < s->ssh.session->recv_seq); + sanity_check_session(state); /* Copy the initial secret hash = session_id so we know we changed keys later */ + c = s->ssh.session->current_crypto; + assert_non_null(c); secret_hash = malloc(c->digest_len); assert_non_null(secret_hash); memcpy(secret_hash, c->secret_hash, c->digest_len); diff --git a/libssh/tests/client/torture_session.c b/libssh/tests/client/torture_session.c index 27e8fc86..c437d421 100644 --- a/libssh/tests/client/torture_session.c +++ b/libssh/tests/client/torture_session.c @@ -391,6 +391,38 @@ static void torture_freed_channel_get_exit_status(void **state) assert_ssh_return_code_equal(session, rc, SSH_ERROR); } +static void torture_pubkey_hash(void **state) +{ + struct torture_state *s = *state; + ssh_session session = s->ssh.session; + char *hash = NULL; + char *hexa = NULL; + int rc = 0; + + /* bad arguments */ + rc = ssh_get_pubkey_hash(session, NULL); + assert_int_equal(rc, SSH_ERROR); + + rc = ssh_get_pubkey_hash(NULL, (unsigned char **)&hash); + assert_int_equal(rc, SSH_ERROR); + + /* deprecated, but should be covered by tests! */ + rc = ssh_get_pubkey_hash(session, (unsigned char **)&hash); + if (ssh_fips_mode()) { + /* When in FIPS mode, expect the call to fail */ + assert_int_equal(rc, SSH_ERROR); + } else { + assert_int_equal(rc, MD5_DIGEST_LEN); + + hexa = ssh_get_hexa((unsigned char *)hash, rc); + SSH_STRING_FREE_CHAR(hash); + assert_string_equal(hexa, + "ee:80:7f:61:f9:d5:be:f1:96:86:cc:96:7a:db:7a:7b"); + + SSH_STRING_FREE_CHAR(hexa); + } +} + int torture_run_tests(void) { int rc; struct CMUnitTest tests[] = { @@ -421,6 +453,9 @@ int torture_run_tests(void) { cmocka_unit_test_setup_teardown(torture_freed_channel_get_exit_status, session_setup, session_teardown), + cmocka_unit_test_setup_teardown(torture_pubkey_hash, + session_setup, + session_teardown), }; ssh_init(); diff --git a/libssh/tests/pkd/CMakeLists.txt b/libssh/tests/pkd/CMakeLists.txt index 0a13da85..3dc72c75 100644 --- a/libssh/tests/pkd/CMakeLists.txt +++ b/libssh/tests/pkd/CMakeLists.txt @@ -34,7 +34,7 @@ target_link_libraries(pkd_hello ${pkd_libs}) # specified with `-i` and may be helpful for chasing down bugs that # are not 100% reproducible. # -add_test(pkd_hello_i1 ${CMAKE_CURRENT_BINARY_DIR}/pkd_hello -e -o -i1 -w /tmp/pkd_socket_wrapper_XXXXXX) +add_test(pkd_hello_i1 ${CMAKE_CURRENT_BINARY_DIR}/pkd_hello -e -o -i1 -w /tmp/pkd_socket_wrapper_XXXXXX -L pkd_scratch_XXXXXX) # # Configure environment for cwrap socket wrapper. # @@ -49,7 +49,7 @@ set_property(TEST pkd_hello_i1 PROPERTY ENVIRONMENT ${PKD_ENVIRONMENT}) # # pkd_hello_rekey is used to test server-side implementation of rekeying. # -add_test(pkd_hello_rekey ${CMAKE_CURRENT_BINARY_DIR}/pkd_hello -t torture_pkd_openssh_rsa_rsa_default -i1 --rekey=16 -v -v -v -w /tmp/pkd_socket_wrapper_XXXXXX) +add_test(pkd_hello_rekey ${CMAKE_CURRENT_BINARY_DIR}/pkd_hello -t torture_pkd_openssh_rsa_rsa_default -i1 --rekey=16 -v -v -v -w /tmp/pkd_socket_wrapper_XXXXXX -L pkd_scratch_XXXXXX) set_property(TEST pkd_hello_rekey PROPERTY ENVIRONMENT OPENSSL_ENABLE_SHA1_SIGNATURES=1) endif (WITH_SERVER AND UNIX AND NOT WIN32) diff --git a/libssh/tests/pkd/pkd_daemon.c b/libssh/tests/pkd/pkd_daemon.c index 5325a5de..70f441b2 100644 --- a/libssh/tests/pkd/pkd_daemon.c +++ b/libssh/tests/pkd/pkd_daemon.c @@ -589,7 +589,8 @@ void pkd_stop(struct pkd_result *out) { close(pkd_state.server_fd); rc = pthread_kill(ctx.tid, SIGUSR1); - assert_int_equal(rc, 0); + assert_int_not_equal(rc, EINVAL); + assert_int_not_equal(rc, ENOTSUP); rc = pthread_join(ctx.tid, NULL); assert_int_equal(rc, 0); diff --git a/libssh/tests/pkd/pkd_daemon.h b/libssh/tests/pkd/pkd_daemon.h index 493326c1..81273912 100644 --- a/libssh/tests/pkd/pkd_daemon.h +++ b/libssh/tests/pkd/pkd_daemon.h @@ -30,6 +30,8 @@ struct pkd_daemon_args { uint64_t rekey_data_limit; + int original_dir_fd; + struct { int list; @@ -44,6 +46,10 @@ struct pkd_daemon_args { struct { char *mkdtemp_str; } socket_wrapper; + + struct { + char *mkdtemp_str; + } temp_dir; } opts; }; diff --git a/libssh/tests/pkd/pkd_hello.c b/libssh/tests/pkd/pkd_hello.c index 01b1b10d..657ce8cc 100644 --- a/libssh/tests/pkd/pkd_hello.c +++ b/libssh/tests/pkd/pkd_hello.c @@ -1,15 +1,16 @@ /* * pkd_hello.c -- * - * (c) 2014, 2017-2018 Jon Simons + * (c) 2014, 2017-2018, 2022 Jon Simons */ #include "config.h" +#include #include // for cmocka #include // for cmocka #include #include -#include // for cmocka +#include #include #include "libssh/priv.h" @@ -33,7 +34,7 @@ static size_t default_payload_len = sizeof(default_payload_buf); #include #define PROGNAME "pkd_hello" #define ARGP_PROGNAME "libssh " PROGNAME -const char *argp_program_version = ARGP_PROGNAME " 2017-07-12"; +const char *argp_program_version = ARGP_PROGNAME " 2022-11-12"; const char *argp_program_bug_address = "Jon Simons "; static char doc[] = \ @@ -61,6 +62,8 @@ static struct argp_option options[] = { "Run each test for the given number of iterations (default is 10)", 0 }, { "match", 'm', "testmatch", 0, "Run all tests with the given string", 0 }, + { "temp-dir", 'L', "", 0, + "Run in a temporary directory using the given mkdtemp template", 0 }, { "socket-wrapper-dir", 'w', "", 0, "Run in socket-wrapper mode using the given mkdtemp directory template", 0 }, { "stdout", 'o', NULL, 0, @@ -90,6 +93,9 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) { case 'l': pkd_dargs.opts.list = 1; break; + case 'L': + pkd_dargs.opts.temp_dir.mkdtemp_str = arg; + break; case 'i': pkd_dargs.opts.iterations = atoi(arg); break; @@ -950,6 +956,52 @@ static int pkd_run_tests(void) { return rc; } +static int pkd_init_temp_dir(void) { + int rc = 0; + char *mkdtemp_str = NULL; + pkd_dargs.original_dir_fd = -1; + + if (pkd_dargs.opts.temp_dir.mkdtemp_str == NULL) { + return 0; + } + + pkd_dargs.original_dir_fd = open(".", O_RDONLY); + if (pkd_dargs.original_dir_fd < 0) { + fprintf(stderr, "pkd_init_temp_dir open failed\n"); + return -1; + } + + mkdtemp_str = strdup(pkd_dargs.opts.temp_dir.mkdtemp_str); + if (mkdtemp_str == NULL) { + fprintf(stderr, "pkd_init_temp_dir strdup failed\n"); + goto errstrdup; + } + pkd_dargs.opts.temp_dir.mkdtemp_str = mkdtemp_str; + + if (mkdtemp(mkdtemp_str) == NULL) { + fprintf(stderr, "pkd_init_temp_dir mkdtemp '%s' failed\n", mkdtemp_str); + goto errmkdtemp; + } + + rc = chdir(mkdtemp_str); + if (rc != 0) { + fprintf(stderr, "pkd_init_temp_dir chdir '%s' failed\n", mkdtemp_str); + goto errchdir; + } + + return 0; + +errchdir: + rmdir(mkdtemp_str); +errmkdtemp: + free(mkdtemp_str); +errstrdup: + close(pkd_dargs.original_dir_fd); + pkd_dargs.original_dir_fd = -1; + rc = -1; + return rc; +} + static int pkd_init_socket_wrapper(void) { int rc = 0; char *mkdtemp_str = NULL; @@ -991,6 +1043,33 @@ static int pkd_rmfiles(const char *path) { return system_checked(bin); } +static int pkd_cleanup_temp_dir(void) { + int rc = 0; + + if (pkd_dargs.opts.temp_dir.mkdtemp_str == NULL) { + return 0; + } + + if (fchdir(pkd_dargs.original_dir_fd) != 0) { + fprintf(stderr, "pkd_cleanup_temp_dir failed fchdir\n"); + rc = -1; + goto out; + } + + if (rmdir(pkd_dargs.opts.temp_dir.mkdtemp_str) != 0) { + fprintf(stderr, "pkd_cleanup_temp_dir rmdir '%s' failed\n", + pkd_dargs.opts.temp_dir.mkdtemp_str); + rc = -1; + goto out; + } + +out: + close(pkd_dargs.original_dir_fd); + pkd_dargs.original_dir_fd = -1; + free(pkd_dargs.opts.temp_dir.mkdtemp_str); + return rc; +} + static int pkd_cleanup_socket_wrapper(void) { int rc = 0; @@ -1011,12 +1090,12 @@ static int pkd_cleanup_socket_wrapper(void) { goto errrmdir; } - free(pkd_dargs.opts.socket_wrapper.mkdtemp_str); - - goto out; + goto outfree; errrmdir: errrmfiles: rc = -1; +outfree: + free(pkd_dargs.opts.socket_wrapper.mkdtemp_str); out: return rc; } @@ -1042,10 +1121,16 @@ int main(int argc, char **argv) { (void) argc; (void) argv; #endif /* HAVE_ARGP_H */ + rc = pkd_init_temp_dir(); + if (rc != 0) { + fprintf(stderr, "pkd_init_temp_dir failed: %d\n", rc); + goto out_finalize; + } + rc = pkd_init_socket_wrapper(); if (rc != 0) { fprintf(stderr, "pkd_init_socket_wrapper failed: %d\n", rc); - goto out_finalize; + goto out_tempdir; } if (pkd_dargs.opts.list != 0) { @@ -1064,6 +1149,12 @@ int main(int argc, char **argv) { fprintf(stderr, "pkd_cleanup_socket_wrapper failed: %d\n", rc); } +out_tempdir: + rc = pkd_cleanup_temp_dir(); + if (rc != 0) { + fprintf(stderr, "pkd_cleanup_temp_dir failed: %d\n", rc); + } + out_finalize: rc = ssh_finalize(); if (rc != 0) { diff --git a/libssh/tests/unittests/torture_config.c b/libssh/tests/unittests/torture_config.c index 406f1985..26a24215 100644 --- a/libssh/tests/unittests/torture_config.c +++ b/libssh/tests/unittests/torture_config.c @@ -995,23 +995,22 @@ static void torture_config_proxyjump(void **state, assert_string_equal(session->opts.ProxyCommand, "ssh -W '[%h]:%p' 2620:52:0::fed"); - /* In this part, we try various other config files and strings. */ - - /* Try to create some invalid configurations */ - /* Non-numeric port */ - config = "Host bad-port\n" - "\tProxyJump jumpbox:22bad22\n"; + /* Multiple @ is allowed in second jump */ + config = "Host allowed-hostname\n" + "\tProxyJump localhost,user@principal.com@jumpbox:22\n"; if (file != NULL) { torture_write_file(file, config); } else { string = config; } torture_reset_config(session); - ssh_options_set(session, SSH_OPTIONS_HOST, "bad-port"); - _parse_config(session, file, string, SSH_ERROR); + ssh_options_set(session, SSH_OPTIONS_HOST, "allowed-hostname"); + _parse_config(session, file, string, SSH_OK); + assert_string_equal(session->opts.ProxyCommand, + "ssh -J user@principal.com@jumpbox:22 -W '[%h]:%p' localhost"); - /* Too many @ */ - config = "Host bad-hostname\n" + /* Multiple @ is allowed */ + config = "Host allowed-hostname\n" "\tProxyJump user@principal.com@jumpbox:22\n"; if (file != NULL) { torture_write_file(file, config); @@ -1019,7 +1018,24 @@ static void torture_config_proxyjump(void **state, string = config; } torture_reset_config(session); - ssh_options_set(session, SSH_OPTIONS_HOST, "bad-hostname"); + ssh_options_set(session, SSH_OPTIONS_HOST, "allowed-hostname"); + _parse_config(session, file, string, SSH_OK); + assert_string_equal(session->opts.ProxyCommand, + "ssh -l user@principal.com -p 22 -W '[%h]:%p' jumpbox"); + + /* In this part, we try various other config files and strings. */ + + /* Try to create some invalid configurations */ + /* Non-numeric port */ + config = "Host bad-port\n" + "\tProxyJump jumpbox:22bad22\n"; + if (file != NULL) { + torture_write_file(file, config); + } else { + string = config; + } + torture_reset_config(session); + ssh_options_set(session, SSH_OPTIONS_HOST, "bad-port"); _parse_config(session, file, string, SSH_ERROR); /* Braces mismatch in hostname */ @@ -1094,18 +1110,6 @@ static void torture_config_proxyjump(void **state, ssh_options_set(session, SSH_OPTIONS_HOST, "bad-port-2"); _parse_config(session, file, string, SSH_ERROR); - /* Too many @ in second jump */ - config = "Host bad-hostname\n" - "\tProxyJump localhost,user@principal.com@jumpbox:22\n"; - if (file != NULL) { - torture_write_file(file, config); - } else { - string = config; - } - torture_reset_config(session); - ssh_options_set(session, SSH_OPTIONS_HOST, "bad-hostname"); - _parse_config(session, file, string, SSH_ERROR); - /* Braces mismatch in second jump */ config = "Host mismatch\n" "\tProxyJump localhost,[::1:20\n"; @@ -1448,10 +1452,10 @@ static void torture_config_parser_get_cmd(void **state) } else if (pid == 0) { ssh_execute_command(tok, fileno(outfile), fileno(outfile)); /* Does not return */ - } else { - /* parent + } else { + /* parent * wait child process */ - wait(NULL); + wait(NULL); infile = fopen("output.log", "r"); assert_non_null(infile); p = fgets(buffer, sizeof(buffer), infile); @@ -1846,6 +1850,53 @@ static void torture_config_make_absolute_no_sshdir(void **state) torture_config_make_absolute_int(state, 1); } +static void torture_config_parse_uri(void **state) +{ + char *username = NULL; + char *hostname = NULL; + char *port = NULL; + int rc; + + (void)state; /* unused */ + + rc = ssh_config_parse_uri("localhost", &username, &hostname, &port, false); + assert_return_code(rc, errno); + assert_null(username); + assert_string_equal(hostname, "localhost"); + SAFE_FREE(hostname); + assert_null(port); + + rc = ssh_config_parse_uri("1.2.3.4", &username, &hostname, &port, false); + assert_return_code(rc, errno); + assert_null(username); + assert_string_equal(hostname, "1.2.3.4"); + SAFE_FREE(hostname); + assert_null(port); + + rc = ssh_config_parse_uri("1.2.3.4:2222", &username, &hostname, &port, false); + assert_return_code(rc, errno); + assert_null(username); + assert_string_equal(hostname, "1.2.3.4"); + SAFE_FREE(hostname); + assert_string_equal(port, "2222"); + SAFE_FREE(port); + + rc = ssh_config_parse_uri("[1:2:3::4]:2222", &username, &hostname, &port, false); + assert_return_code(rc, errno); + assert_null(username); + assert_string_equal(hostname, "1:2:3::4"); + SAFE_FREE(hostname); + assert_string_equal(port, "2222"); + SAFE_FREE(port); + + /* do not want port */ + rc = ssh_config_parse_uri("1:2:3::4", &username, &hostname, NULL, true); + assert_return_code(rc, errno); + assert_null(username); + assert_string_equal(hostname, "1:2:3::4"); + SAFE_FREE(hostname); +} + int torture_run_tests(void) { int rc; @@ -1918,6 +1969,8 @@ int torture_run_tests(void) setup, teardown), cmocka_unit_test_setup_teardown(torture_config_make_absolute_no_sshdir, setup_no_sshdir, teardown), + cmocka_unit_test_setup_teardown(torture_config_parse_uri, + setup, teardown), }; diff --git a/libssh/tests/unittests/torture_misc.c b/libssh/tests/unittests/torture_misc.c index 9e346ff8..77166759 100644 --- a/libssh/tests/unittests/torture_misc.c +++ b/libssh/tests/unittests/torture_misc.c @@ -17,7 +17,14 @@ #include "torture.h" #include "error.c" +#ifdef _WIN32 +#include +#else +#include +#endif + #define TORTURE_TEST_DIR "/usr/local/bin/truc/much/.." +#define TORTURE_IPV6_LOCAL_LINK "fe80::98e1:82ff:fe8d:28b3%%%s" const char template[] = "temp_dir_XXXXXX"; @@ -760,6 +767,116 @@ static void torture_ssh_strerror(void **state) assert_non_null(out); } +static void torture_ssh_check_hostname_syntax(void **state) +{ + int rc; + (void)state; + + rc = ssh_check_hostname_syntax("duckduckgo.com"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("www.libssh.org"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("Some-Thing.com"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("amazon.a23456789012345678901234567890123456789012345678901234567890123"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("amazon.a23456789012345678901234567890123456789012345678901234567890123.a23456789012345678901234567890123456789012345678901234567890123.ok"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("amazon.a23456789012345678901234567890123456789012345678901234567890123.a23456789012345678901234567890123456789012345678901234567890123.a23456789012345678901234567890123456789012345678901234567890123"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("lavabo-inter.innocentes-manus-meas"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("localhost"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("a"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("a-0.b-b"); + assert_int_equal(rc, SSH_OK); + rc = ssh_check_hostname_syntax("libssh."); + assert_int_equal(rc, SSH_OK); + + rc = ssh_check_hostname_syntax(NULL); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax(""); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("/"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("@"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("["); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("`"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("{"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("&"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("|"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("\""); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("`"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax(" "); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("*the+giant&\"rooks\".c0m"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("!www.libssh.org"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("--.--"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("libssh.a234567890123456789012345678901234567890123456789012345678901234"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("libssh.a234567890123456789012345678901234567890123456789012345678901234.a234567890123456789012345678901234567890123456789012345678901234"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("libssh-"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("fe80::9656:d028:8652:66b6"); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax("."); + assert_int_equal(rc, SSH_ERROR); + rc = ssh_check_hostname_syntax(".."); + assert_int_equal(rc, SSH_ERROR); +} + +static void torture_ssh_is_ipaddr(void **state) { + int rc; + char *interf = malloc(64); + char *test_interf = malloc(128); + (void)state; + + assert_non_null(interf); + assert_non_null(test_interf); + rc = ssh_is_ipaddr("201.255.3.69"); + assert_int_equal(rc, 1); + rc = ssh_is_ipaddr("::1"); + assert_int_equal(rc, 1); + rc = ssh_is_ipaddr("2001:0db8:85a3:0000:0000:8a2e:0370:7334"); + assert_int_equal(rc, 1); + if_indextoname(1, interf); + assert_non_null(interf); + rc = sprintf(test_interf, TORTURE_IPV6_LOCAL_LINK, interf); + /* the "%%s" is not written */ + assert_int_equal(rc, strlen(interf) + strlen(TORTURE_IPV6_LOCAL_LINK) - 3); + rc = ssh_is_ipaddr(test_interf); + assert_int_equal(rc, 1); + free(interf); + free(test_interf); + + rc = ssh_is_ipaddr(".."); + assert_int_equal(rc, 0); + rc = ssh_is_ipaddr(":::"); + assert_int_equal(rc, 0); + rc = ssh_is_ipaddr("1.1.1.1.1"); + assert_int_equal(rc, 0); + rc = ssh_is_ipaddr("1.1"); + assert_int_equal(rc, 0); + rc = ssh_is_ipaddr("caesar"); + assert_int_equal(rc, 0); + rc = ssh_is_ipaddr("::xa:1"); + assert_int_equal(rc, 0); +} + int torture_run_tests(void) { int rc; struct CMUnitTest tests[] = { @@ -784,6 +901,8 @@ int torture_run_tests(void) { cmocka_unit_test(torture_ssh_quote_file_name), cmocka_unit_test(torture_ssh_strreplace), cmocka_unit_test(torture_ssh_strerror), + cmocka_unit_test(torture_ssh_check_hostname_syntax), + cmocka_unit_test(torture_ssh_is_ipaddr), }; ssh_init(); diff --git a/libssh/tests/unittests/torture_options.c b/libssh/tests/unittests/torture_options.c index 425d7295..8a5505a1 100644 --- a/libssh/tests/unittests/torture_options.c +++ b/libssh/tests/unittests/torture_options.c @@ -60,6 +60,20 @@ static void torture_options_set_host(void **state) { assert_non_null(session->opts.host); assert_string_equal(session->opts.host, "localhost"); + /* IPv4 address */ + rc = ssh_options_set(session, SSH_OPTIONS_HOST, "127.1.1.1"); + assert_true(rc == 0); + assert_non_null(session->opts.host); + assert_string_equal(session->opts.host, "127.1.1.1"); + assert_null(session->opts.username); + + /* IPv6 address */ + rc = ssh_options_set(session, SSH_OPTIONS_HOST, "::1"); + assert_true(rc == 0); + assert_non_null(session->opts.host); + assert_string_equal(session->opts.host, "::1"); + assert_null(session->opts.username); + rc = ssh_options_set(session, SSH_OPTIONS_HOST, "guru@meditation"); assert_true(rc == 0); assert_non_null(session->opts.host); @@ -67,12 +81,14 @@ static void torture_options_set_host(void **state) { assert_non_null(session->opts.username); assert_string_equal(session->opts.username, "guru"); + /* more @ in uri is OK -- it should go to the username */ rc = ssh_options_set(session, SSH_OPTIONS_HOST, "at@login@hostname"); assert_true(rc == 0); assert_non_null(session->opts.host); assert_string_equal(session->opts.host, "hostname"); assert_non_null(session->opts.username); assert_string_equal(session->opts.username, "at@login"); + } static void torture_options_set_ciphers(void **state) { From 64a9748e744409ba68726d158e8e3c56c40cb9eb Mon Sep 17 00:00:00 2001 From: zephyrj Date: Thu, 23 May 2024 12:56:14 +0100 Subject: [PATCH 2/4] Rebuild .c files with version of cython that supports python 3.12 --- setup.py | 18 +- ssh/callbacks.c | 6355 ++++++++++++--- ssh/channel.c | 12576 ++++++++++++++++++++++------ ssh/connector.c | 8788 ++++++++++++++++---- ssh/error_codes.c | 2561 ++++-- ssh/event.c | 8359 +++++++++++++++---- ssh/exceptions.c | 5020 +++++++++--- ssh/key.c | 8075 ++++++++++++++---- ssh/keytypes.c | 11943 +++++++++++++++++++++------ ssh/options.c | 7115 ++++++++++++---- ssh/scp.c | 9073 +++++++++++++++++---- ssh/session.c | 17586 ++++++++++++++++++++++++++++++++-------- ssh/sftp.c | 10955 ++++++++++++++++++++----- ssh/sftp_attributes.c | 8717 +++++++++++++++----- ssh/sftp_handles.c | 12194 +++++++++++++++++++++------- ssh/sftp_statvfs.c | 6597 ++++++++++++--- ssh/utils.c | 5814 ++++++++++--- 17 files changed, 112933 insertions(+), 28813 deletions(-) diff --git a/setup.py b/setup.py index 7aceadef..69705113 100644 --- a/setup.py +++ b/setup.py @@ -12,6 +12,7 @@ try: from Cython.Distutils.extension import Extension from Cython.Distutils import build_ext + from Cython.Build import cythonize except ImportError: from setuptools import Extension USING_CYTHON = False @@ -48,7 +49,7 @@ # _comp_args = ["-ggdb"] _comp_args = ['-O2', '-g0', '-s'] if not ON_WINDOWS else None -cython_directives = { +compiler_directives = { 'embedsignature': True, 'boundscheck': False, 'optimize.use_switch': True, @@ -56,11 +57,10 @@ 'language_level': 2, } cython_args = { - 'cython_directives': cython_directives, - 'cython_compile_time_env': { + 'compiler_directives': compiler_directives, + 'compile_time_env': { 'ON_WINDOWS': ON_WINDOWS, - }} \ - if USING_CYTHON else {} + }} runtime_library_dirs = ["$ORIGIN/."] if not SYSTEM_LIBSSH else None @@ -79,8 +79,7 @@ libraries=_libs, library_dirs=lib_dirs, runtime_library_dirs=runtime_library_dirs, - extra_compile_args=_comp_args, - **cython_args + extra_compile_args=_comp_args ) for i in range(len(sources))] @@ -104,7 +103,7 @@ name='ssh-python', version=versioneer.get_version(), cmdclass=cmdclass, - url='https://github.com/ParallelSSH/ssh-python', + url='https://github.com/parallel-ssh/ssh-python', license='LGPLv2.1', author='Panos Kittenis', author_email='22e889d8@opayq.com', @@ -130,6 +129,7 @@ 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', + 'Programming Language :: Python :: 3.12', 'Topic :: System :: Shells', 'Topic :: System :: Networking', 'Topic :: Software Development :: Libraries', @@ -140,6 +140,6 @@ 'Operating System :: MacOS :: MacOS X', 'Operating System :: Microsoft :: Windows', ], - ext_modules=extensions, + ext_modules=cythonize(extensions, **cython_args) if USING_CYTHON else extensions, package_data=package_data, ) diff --git a/ssh/callbacks.c b/ssh/callbacks.c index 29a070aa..02d0e3f9 100644 --- a/ssh/callbacks.c +++ b/ssh/callbacks.c @@ -1,22 +1,73 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/callbacks.h", + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.callbacks", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/callbacks.pyx" + ] + }, + "module_name": "ssh.callbacks" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +86,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +94,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +131,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +151,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +279,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +308,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +319,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +342,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +369,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +393,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +477,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +501,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +518,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +580,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +615,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +767,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +784,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else -#define __Pyx_PyFastCFunction_Check(func) 0 + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +874,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +920,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +954,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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 + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1048,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1063,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1105,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1122,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1169,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1189,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1229,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -796,9 +1308,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -816,9 +1329,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -826,13 +1339,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -856,14 +1363,60 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; @@ -878,7 +1431,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -908,6 +1461,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -943,24 +1497,27 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "ssh/callbacks.pyx", - "stringsource", + "", "ssh/session.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -968,11 +1525,9 @@ static const char *__pyx_f[] = { #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_3ssh_7session_Session; @@ -1004,6 +1559,7 @@ struct __pyx_obj_3ssh_9callbacks_Callbacks { ssh_callbacks _cb; }; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1012,11 +1568,11 @@ struct __pyx_obj_3ssh_9callbacks_Callbacks { #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1026,28 +1582,40 @@ struct __pyx_obj_3ssh_9callbacks_Callbacks { #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1058,6 +1626,10 @@ struct __pyx_obj_3ssh_9callbacks_Callbacks { #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);\ @@ -1069,6 +1641,57 @@ struct __pyx_obj_3ssh_9callbacks_Callbacks { #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); @@ -1076,38 +1699,45 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif -#if CYTHON_FAST_PYCALL - static size_t __pyx_pyframe_localsplus_offset = 0; +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif // CYTHON_FAST_PYCALL +#endif +#endif #endif /* PyObjectCall.proto */ @@ -1122,39 +1752,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) -#endif - -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); -#else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) -#endif - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); /* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) @@ -1166,14 +1772,6 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) @@ -1182,52 +1780,123 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +/* TupleAndListFromArray.proto */ #if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) #else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) #endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) #else -#define __Pyx_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) + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif -/* WriteUnraisableException.proto */ -static void __Pyx_WriteUnraisable(const char *name, int clineno, - int lineno, const char *filename, - int full_traceback, int nogil); - /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); @@ -1242,23 +1911,170 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 }; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif #endif +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1293,6 +2109,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1306,13 +2123,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif @@ -1322,6 +2140,19 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1331,84 +2162,100 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionImport.proto */ -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "libc.time" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'ssh.c_callbacks' */ +/* Module declarations from "ssh.c_callbacks" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'libc.stdlib' */ +/* Module declarations from "libc.stdlib" */ -/* Module declarations from 'ssh.session' */ -static PyTypeObject *__pyx_ptype_3ssh_7session_Session = 0; +/* Module declarations from "ssh.session" */ -/* Module declarations from 'ssh.utils' */ +/* Module declarations from "ssh.utils" */ static int (*__pyx_f_3ssh_5utils_handle_error_codes)(int, ssh_session); /*proto*/ -/* Module declarations from 'ssh.callbacks' */ -static PyTypeObject *__pyx_ptype_3ssh_9callbacks_Callbacks = 0; +/* Module declarations from "ssh.callbacks" */ static int __pyx_f_3ssh_9callbacks_auth_callback(char const *, char *, size_t, int, int, void *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.callbacks" extern int __pyx_module_is_main_ssh__callbacks; int __pyx_module_is_main_ssh__callbacks = 0; -/* Implementation of 'ssh.callbacks' */ +/* Implementation of "ssh.callbacks" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_TypeError; +/* #### Code section: string_decls ### */ +static const char __pyx_k__9[] = "?"; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_rc[] = "rc"; +static const char __pyx_k_func[] = "func"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_session[] = "session"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_Callbacks[] = "Callbacks"; static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_set_userdata[] = "set_userdata"; +static const char __pyx_k_stringsource[] = ""; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_set_callbacks[] = "set_callbacks"; +static const char __pyx_k_ssh_callbacks[] = "ssh.callbacks"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_ssh_callbacks_pyx[] = "ssh/callbacks.pyx"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_Callbacks_set_userdata[] = "Callbacks.set_userdata"; +static const char __pyx_k_Callbacks_set_callbacks[] = "Callbacks.set_callbacks"; +static const char __pyx_k_Callbacks___reduce_cython[] = "Callbacks.__reduce_cython__"; +static const char __pyx_k_Callbacks___setstate_cython[] = "Callbacks.__setstate_cython__"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static PyObject *__pyx_n_s_Callbacks; -static PyObject *__pyx_n_s_MemoryError; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_test; +/* #### Code section: decls ### */ static int __pyx_pf_3ssh_9callbacks_9Callbacks___cinit__(struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self); /* proto */ static void __pyx_pf_3ssh_9callbacks_9Callbacks_2__dealloc__(struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_4set_userdata(struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self, PyObject *__pyx_v_func); /* proto */ @@ -1416,9 +2263,348 @@ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_6set_callbacks(struct __pyx static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_3ssh_9callbacks_Callbacks(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -/* Late includes */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_3ssh_7session_Session; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_3ssh_9callbacks_Callbacks; + #endif + PyTypeObject *__pyx_ptype_3ssh_9callbacks_Callbacks; + PyObject *__pyx_n_s_Callbacks; + PyObject *__pyx_n_s_Callbacks___reduce_cython; + PyObject *__pyx_n_s_Callbacks___setstate_cython; + PyObject *__pyx_n_s_Callbacks_set_callbacks; + PyObject *__pyx_n_s_Callbacks_set_userdata; + PyObject *__pyx_n_s_MemoryError; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s__9; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_func; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_rc; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_session; + PyObject *__pyx_n_s_set_callbacks; + PyObject *__pyx_n_s_set_userdata; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_ssh_callbacks; + PyObject *__pyx_kp_s_ssh_callbacks_pyx; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__5; + PyObject *__pyx_tuple__7; + PyObject *__pyx_codeobj__2; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__6; + PyObject *__pyx_codeobj__8; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_7session_Session); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_9callbacks_Callbacks); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_9callbacks_Callbacks); + Py_CLEAR(clear_module_state->__pyx_n_s_Callbacks); + Py_CLEAR(clear_module_state->__pyx_n_s_Callbacks___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Callbacks___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Callbacks_set_callbacks); + Py_CLEAR(clear_module_state->__pyx_n_s_Callbacks_set_userdata); + Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s__9); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_func); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_rc); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_session); + Py_CLEAR(clear_module_state->__pyx_n_s_set_callbacks); + Py_CLEAR(clear_module_state->__pyx_n_s_set_userdata); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_callbacks); + Py_CLEAR(clear_module_state->__pyx_kp_s_ssh_callbacks_pyx); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__5); + Py_CLEAR(clear_module_state->__pyx_tuple__7); + Py_CLEAR(clear_module_state->__pyx_codeobj__2); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__6); + Py_CLEAR(clear_module_state->__pyx_codeobj__8); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_7session_Session); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_9callbacks_Callbacks); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_9callbacks_Callbacks); + Py_VISIT(traverse_module_state->__pyx_n_s_Callbacks); + Py_VISIT(traverse_module_state->__pyx_n_s_Callbacks___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Callbacks___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Callbacks_set_callbacks); + Py_VISIT(traverse_module_state->__pyx_n_s_Callbacks_set_userdata); + Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s__9); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_func); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_rc); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_session); + Py_VISIT(traverse_module_state->__pyx_n_s_set_callbacks); + Py_VISIT(traverse_module_state->__pyx_n_s_set_userdata); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_callbacks); + Py_VISIT(traverse_module_state->__pyx_kp_s_ssh_callbacks_pyx); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__5); + Py_VISIT(traverse_module_state->__pyx_tuple__7); + Py_VISIT(traverse_module_state->__pyx_codeobj__2); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__6); + Py_VISIT(traverse_module_state->__pyx_codeobj__8); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_3ssh_7session_Session __pyx_mstate_global->__pyx_ptype_3ssh_7session_Session +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_3ssh_9callbacks_Callbacks __pyx_mstate_global->__pyx_type_3ssh_9callbacks_Callbacks +#endif +#define __pyx_ptype_3ssh_9callbacks_Callbacks __pyx_mstate_global->__pyx_ptype_3ssh_9callbacks_Callbacks +#define __pyx_n_s_Callbacks __pyx_mstate_global->__pyx_n_s_Callbacks +#define __pyx_n_s_Callbacks___reduce_cython __pyx_mstate_global->__pyx_n_s_Callbacks___reduce_cython +#define __pyx_n_s_Callbacks___setstate_cython __pyx_mstate_global->__pyx_n_s_Callbacks___setstate_cython +#define __pyx_n_s_Callbacks_set_callbacks __pyx_mstate_global->__pyx_n_s_Callbacks_set_callbacks +#define __pyx_n_s_Callbacks_set_userdata __pyx_mstate_global->__pyx_n_s_Callbacks_set_userdata +#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s__9 __pyx_mstate_global->__pyx_n_s__9 +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_func __pyx_mstate_global->__pyx_n_s_func +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session +#define __pyx_n_s_set_callbacks __pyx_mstate_global->__pyx_n_s_set_callbacks +#define __pyx_n_s_set_userdata __pyx_mstate_global->__pyx_n_s_set_userdata +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_ssh_callbacks __pyx_mstate_global->__pyx_n_s_ssh_callbacks +#define __pyx_kp_s_ssh_callbacks_pyx __pyx_mstate_global->__pyx_kp_s_ssh_callbacks_pyx +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 +#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 +#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 +#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8 +/* #### Code section: module_code ### */ /* "ssh/callbacks.pyx":27 * @@ -1442,7 +2628,7 @@ static int __pyx_f_3ssh_9callbacks_auth_callback(CYTHON_UNUSED char const *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("auth_callback", 0); + __Pyx_RefNannySetupContext("auth_callback", 1); /* "ssh/callbacks.pyx":29 * cdef int auth_callback(const char *prompt, char *buf, size_t len, @@ -1481,20 +2667,27 @@ static int __pyx_f_3ssh_9callbacks_auth_callback(CYTHON_UNUSED char const *__pyx */ __Pyx_INCREF(__pyx_v_func); __pyx_t_5 = __pyx_v_func; __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; } } - __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L3_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_7; @@ -1524,9 +2717,9 @@ static int __pyx_f_3ssh_9callbacks_auth_callback(CYTHON_UNUSED char const *__pyx if (__pyx_t_7) { __Pyx_AddTraceback("ssh.callbacks.auth_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(0, 32, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); /* "ssh/callbacks.pyx":34 * except Exception: @@ -1542,7 +2735,6 @@ static int __pyx_f_3ssh_9callbacks_auth_callback(CYTHON_UNUSED char const *__pyx goto __pyx_L6_except_return; } goto __pyx_L5_except_error; - __pyx_L5_except_error:; /* "ssh/callbacks.pyx":29 * cdef int auth_callback(const char *prompt, char *buf, size_t len, @@ -1551,6 +2743,7 @@ static int __pyx_f_3ssh_9callbacks_auth_callback(CYTHON_UNUSED char const *__pyx * func = userdata * return func() */ + __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); @@ -1583,8 +2776,8 @@ static int __pyx_f_3ssh_9callbacks_auth_callback(CYTHON_UNUSED char const *__pyx __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_WriteUnraisable("ssh.callbacks.auth_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __pyx_r = 0; + __Pyx_AddTraceback("ssh.callbacks.auth_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_func); __Pyx_RefNannyFinishContext(); @@ -1602,12 +2795,20 @@ static int __pyx_f_3ssh_9callbacks_auth_callback(CYTHON_UNUSED char const *__pyx /* Python wrapper */ static int __pyx_pw_3ssh_9callbacks_9Callbacks_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_9callbacks_9Callbacks_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks___cinit__(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self)); /* function exit code */ @@ -1617,12 +2818,10 @@ static int __pyx_pw_3ssh_9callbacks_9Callbacks_1__cinit__(PyObject *__pyx_v_self static int __pyx_pf_3ssh_9callbacks_9Callbacks___cinit__(struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/callbacks.pyx":41 * @@ -1640,7 +2839,7 @@ static int __pyx_pf_3ssh_9callbacks_9Callbacks___cinit__(struct __pyx_obj_3ssh_9 * raise MemoryError * memset(self._cb, 0, sizeof(c_callbacks.ssh_callbacks_struct)) */ - __pyx_t_1 = ((__pyx_v_self->_cb == NULL) != 0); + __pyx_t_1 = (__pyx_v_self->_cb == NULL); if (unlikely(__pyx_t_1)) { /* "ssh/callbacks.pyx":44 @@ -1703,7 +2902,6 @@ static int __pyx_pf_3ssh_9callbacks_9Callbacks___cinit__(struct __pyx_obj_3ssh_9 __Pyx_AddTraceback("ssh.callbacks.Callbacks.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1718,8 +2916,10 @@ static int __pyx_pf_3ssh_9callbacks_9Callbacks___cinit__(struct __pyx_obj_3ssh_9 /* Python wrapper */ static void __pyx_pw_3ssh_9callbacks_9Callbacks_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_3ssh_9callbacks_9Callbacks_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_3ssh_9callbacks_9Callbacks_2__dealloc__(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self)); /* function exit code */ @@ -1727,9 +2927,7 @@ static void __pyx_pw_3ssh_9callbacks_9Callbacks_3__dealloc__(PyObject *__pyx_v_s } static void __pyx_pf_3ssh_9callbacks_9Callbacks_2__dealloc__(struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "ssh/callbacks.pyx":56 * @@ -1738,7 +2936,7 @@ static void __pyx_pf_3ssh_9callbacks_9Callbacks_2__dealloc__(struct __pyx_obj_3s * free(self._cb) * self._cb = NULL */ - __pyx_t_1 = ((__pyx_v_self->_cb != NULL) != 0); + __pyx_t_1 = (__pyx_v_self->_cb != NULL); if (__pyx_t_1) { /* "ssh/callbacks.pyx":57 @@ -1777,7 +2975,6 @@ static void __pyx_pf_3ssh_9callbacks_9Callbacks_2__dealloc__(struct __pyx_obj_3s */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "ssh/callbacks.pyx":60 @@ -1789,25 +2986,105 @@ static void __pyx_pf_3ssh_9callbacks_9Callbacks_2__dealloc__(struct __pyx_obj_3s */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata(PyObject *__pyx_v_self, PyObject *__pyx_v_func); /*proto*/ -static char __pyx_doc_3ssh_9callbacks_9Callbacks_4set_userdata[] = "Callbacks.set_userdata(self, func)"; -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata(PyObject *__pyx_v_self, PyObject *__pyx_v_func) { - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9callbacks_9Callbacks_4set_userdata, "Callbacks.set_userdata(self, func)"); +static PyMethodDef __pyx_mdef_3ssh_9callbacks_9Callbacks_5set_userdata = {"set_userdata", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_4set_userdata}; +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata(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_func = 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("set_userdata (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_func)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 60, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_userdata") < 0)) __PYX_ERR(0, 60, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_func = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_userdata", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 60, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.callbacks.Callbacks.set_userdata", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(((PyObject *)__pyx_v_func) == Py_None)) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "func"); __PYX_ERR(0, 60, __pyx_L1_error) } - __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks_4set_userdata(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self), ((PyObject *)__pyx_v_func)); + __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks_4set_userdata(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self), __pyx_v_func); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1815,7 +3092,7 @@ static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata(PyObject *__p static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_4set_userdata(struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self, PyObject *__pyx_v_func) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("set_userdata", 0); + __Pyx_RefNannySetupContext("set_userdata", 1); /* "ssh/callbacks.pyx":61 * @@ -1850,23 +3127,103 @@ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_4set_userdata(struct __pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_7set_callbacks(PyObject *__pyx_v_self, PyObject *__pyx_v_session); /*proto*/ -static char __pyx_doc_3ssh_9callbacks_9Callbacks_6set_callbacks[] = "Callbacks.set_callbacks(self, Session session)"; -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_7set_callbacks(PyObject *__pyx_v_self, PyObject *__pyx_v_session) { +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_7set_callbacks(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9callbacks_9Callbacks_6set_callbacks, "Callbacks.set_callbacks(self, Session session)"); +static PyMethodDef __pyx_mdef_3ssh_9callbacks_9Callbacks_7set_callbacks = {"set_callbacks", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_7set_callbacks, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_6set_callbacks}; +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_7set_callbacks(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 +) { + struct __pyx_obj_3ssh_7session_Session *__pyx_v_session = 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("set_callbacks (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_callbacks") < 0)) __PYX_ERR(0, 63, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_session = ((struct __pyx_obj_3ssh_7session_Session *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_callbacks", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 63, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.callbacks.Callbacks.set_callbacks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_3ssh_7session_Session, 0, "session", 0))) __PYX_ERR(0, 63, __pyx_L1_error) - __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks_6set_callbacks(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self), ((struct __pyx_obj_3ssh_7session_Session *)__pyx_v_session)); + __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks_6set_callbacks(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self), __pyx_v_session); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1880,7 +3237,7 @@ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_6set_callbacks(struct __pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_callbacks", 0); + __Pyx_RefNannySetupContext("set_callbacks", 1); /* "ssh/callbacks.pyx":65 * def set_callbacks(self, Session session not None): @@ -1892,6 +3249,7 @@ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_6set_callbacks(struct __pyx { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -1960,17 +3318,45 @@ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_6set_callbacks(struct __pyx /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_9callbacks_9Callbacks_8__reduce_cython__[] = "Callbacks.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9callbacks_9Callbacks_8__reduce_cython__, "Callbacks.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_9callbacks_9Callbacks_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_8__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks_8__reduce_cython__(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self)); /* function exit code */ @@ -1981,33 +3367,28 @@ static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__(PyObject static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_9callbacks_Callbacks *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.callbacks.Callbacks.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2017,21 +3398,104 @@ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_8__reduce_cython__(CYTHON_U /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_9callbacks_9Callbacks_10__setstate_cython__[] = "Callbacks.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9callbacks_9Callbacks_10__setstate_cython__, "Callbacks.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_9callbacks_9Callbacks_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_10__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks_10__setstate_cython__(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.callbacks.Callbacks.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_9callbacks_9Callbacks_10__setstate_cython__(((struct __pyx_obj_3ssh_9callbacks_Callbacks *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2039,33 +3503,28 @@ static PyObject *__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__(PyObj static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_9callbacks_Callbacks *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.callbacks.Callbacks.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2075,12 +3534,17 @@ static PyObject *__pyx_pf_3ssh_9callbacks_9Callbacks_10__setstate_cython__(CYTHO static PyObject *__pyx_tp_new_3ssh_9callbacks_Callbacks(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif if (unlikely(__pyx_pw_3ssh_9callbacks_9Callbacks_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; return o; bad: @@ -2090,8 +3554,10 @@ static PyObject *__pyx_tp_new_3ssh_9callbacks_Callbacks(PyTypeObject *t, CYTHON_ static void __pyx_tp_dealloc_3ssh_9callbacks_Callbacks(PyObject *o) { #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { - if (PyObject_CallFinalizerFromDealloc(o)) return; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_3ssh_9callbacks_Callbacks) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -2102,20 +3568,42 @@ static void __pyx_tp_dealloc_3ssh_9callbacks_Callbacks(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_3ssh_9callbacks_Callbacks[] = { - {"set_userdata", (PyCFunction)__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata, METH_O, __pyx_doc_3ssh_9callbacks_9Callbacks_4set_userdata}, - {"set_callbacks", (PyCFunction)__pyx_pw_3ssh_9callbacks_9Callbacks_7set_callbacks, METH_O, __pyx_doc_3ssh_9callbacks_9Callbacks_6set_callbacks}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_9callbacks_9Callbacks_8__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__, METH_O, __pyx_doc_3ssh_9callbacks_9Callbacks_10__setstate_cython__}, + {"set_userdata", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_5set_userdata, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_4set_userdata}, + {"set_callbacks", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_7set_callbacks, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_6set_callbacks}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_8__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9callbacks_9Callbacks_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9callbacks_9Callbacks_10__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_9callbacks_Callbacks_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_3ssh_9callbacks_Callbacks}, + {Py_tp_methods, (void *)__pyx_methods_3ssh_9callbacks_Callbacks}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_9callbacks_Callbacks}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_9callbacks_Callbacks_spec = { + "ssh.callbacks.Callbacks", + sizeof(struct __pyx_obj_3ssh_9callbacks_Callbacks), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_9callbacks_Callbacks_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_9callbacks_Callbacks = { PyVarObject_HEAD_INIT(0, 0) - "ssh.callbacks.Callbacks", /*tp_name*/ + "ssh.callbacks.""Callbacks", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_9callbacks_Callbacks), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_9callbacks_Callbacks, /*tp_dealloc*/ @@ -2158,7 +3646,9 @@ static PyTypeObject __pyx_type_3ssh_9callbacks_Callbacks = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_9callbacks_Callbacks, /*tp_new*/ @@ -2172,54 +3662,30 @@ static PyTypeObject __pyx_type_3ssh_9callbacks_Callbacks = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_callbacks(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_callbacks}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "callbacks", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -2229,24 +3695,50 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_Callbacks, __pyx_k_Callbacks, sizeof(__pyx_k_Callbacks), 0, 0, 1, 1}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_Callbacks, __pyx_k_Callbacks, sizeof(__pyx_k_Callbacks), 0, 0, 1, 1}, + {&__pyx_n_s_Callbacks___reduce_cython, __pyx_k_Callbacks___reduce_cython, sizeof(__pyx_k_Callbacks___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Callbacks___setstate_cython, __pyx_k_Callbacks___setstate_cython, sizeof(__pyx_k_Callbacks___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Callbacks_set_callbacks, __pyx_k_Callbacks_set_callbacks, sizeof(__pyx_k_Callbacks_set_callbacks), 0, 0, 1, 1}, + {&__pyx_n_s_Callbacks_set_userdata, __pyx_k_Callbacks_set_userdata, sizeof(__pyx_k_Callbacks_set_userdata), 0, 0, 1, 1}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_func, __pyx_k_func, sizeof(__pyx_k_func), 0, 0, 1, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1}, + {&__pyx_n_s_set_callbacks, __pyx_k_set_callbacks, sizeof(__pyx_k_set_callbacks), 0, 0, 1, 1}, + {&__pyx_n_s_set_userdata, __pyx_k_set_userdata, sizeof(__pyx_k_set_userdata), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ssh_callbacks, __pyx_k_ssh_callbacks, sizeof(__pyx_k_ssh_callbacks), 0, 0, 1, 1}, + {&__pyx_kp_s_ssh_callbacks_pyx, __pyx_k_ssh_callbacks_pyx, sizeof(__pyx_k_ssh_callbacks_pyx), 0, 0, 1, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 44, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) @@ -2254,42 +3746,76 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_L1_error:; return -1; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "ssh/callbacks.pyx":60 + * self._cb = NULL + * + * def set_userdata(self, func not None): # <<<<<<<<<<<<<< + * self._cb.userdata = func + * */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_func); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_callbacks_pyx, __pyx_n_s_set_userdata, 60, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 60, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "ssh/callbacks.pyx":63 + * self._cb.userdata = func + * + * def set_callbacks(self, Session session not None): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__3 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_session, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_callbacks_pyx, __pyx_n_s_set_callbacks, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 63, __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): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } +/* #### Code section: init_constants ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -2330,16 +3856,29 @@ static int __Pyx_modinit_type_init_code(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ - if (PyType_Ready(&__pyx_type_3ssh_9callbacks_Callbacks) < 0) __PYX_ERR(0, 38, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_9callbacks_Callbacks.tp_print = 0; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_3ssh_9callbacks_Callbacks = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_9callbacks_Callbacks_spec, NULL); if (unlikely(!__pyx_ptype_3ssh_9callbacks_Callbacks)) __PYX_ERR(0, 38, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_9callbacks_Callbacks_spec, __pyx_ptype_3ssh_9callbacks_Callbacks) < 0) __PYX_ERR(0, 38, __pyx_L1_error) + #else + __pyx_ptype_3ssh_9callbacks_Callbacks = &__pyx_type_3ssh_9callbacks_Callbacks; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_9callbacks_Callbacks) < 0) __PYX_ERR(0, 38, __pyx_L1_error) #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_9callbacks_Callbacks.tp_dictoffset && __pyx_type_3ssh_9callbacks_Callbacks.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_9callbacks_Callbacks.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_9callbacks_Callbacks->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_9callbacks_Callbacks->tp_dictoffset && __pyx_ptype_3ssh_9callbacks_Callbacks->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_9callbacks_Callbacks->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Callbacks, (PyObject *)&__pyx_type_3ssh_9callbacks_Callbacks) < 0) __PYX_ERR(0, 38, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_9callbacks_Callbacks) < 0) __PYX_ERR(0, 38, __pyx_L1_error) - __pyx_ptype_3ssh_9callbacks_Callbacks = &__pyx_type_3ssh_9callbacks_Callbacks; + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Callbacks, (PyObject *) __pyx_ptype_3ssh_9callbacks_Callbacks) < 0) __PYX_ERR(0, 38, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_9callbacks_Callbacks) < 0) __PYX_ERR(0, 38, __pyx_L1_error) + #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -2357,8 +3896,7 @@ static int __Pyx_modinit_type_import_code(void) { /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule("ssh.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error) + __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -2386,7 +3924,7 @@ static int __Pyx_modinit_function_import_code(void) { /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -2397,6 +3935,55 @@ static int __Pyx_modinit_function_import_code(void) { } +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_callbacks(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_callbacks}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "callbacks", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 @@ -2447,12 +4034,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -2462,8 +4058,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -2473,8 +4070,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -2490,7 +4091,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_callbacks(PyObject *__pyx_pyinit_m #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -2504,6 +4110,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_callbacks(PyObject *__pyx_pyinit_m #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("callbacks", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "callbacks" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -2514,7 +4147,7 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_callbacks(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif @@ -2522,48 +4155,31 @@ if (!__Pyx_RefNanny) { __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("callbacks", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -2575,7 +4191,7 @@ if (!__Pyx_RefNanny) { { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "ssh.callbacks")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.callbacks", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "ssh.callbacks", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif @@ -2587,35 +4203,92 @@ if (!__Pyx_RefNanny) { (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif - /* "ssh/callbacks.pyx":1 - * # This file is part of ssh-python. # <<<<<<<<<<<<<< - * # Copyright (C) 2018 Panos Kittenis - * # + /* "ssh/callbacks.pyx":60 + * self._cb = NULL + * + * def set_userdata(self, func not None): # <<<<<<<<<<<<<< + * self._cb.userdata = func + * */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9callbacks_9Callbacks_5set_userdata, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Callbacks_set_userdata, NULL, __pyx_n_s_ssh_callbacks, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9callbacks_Callbacks, __pyx_n_s_set_userdata, __pyx_t_2) < 0) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9callbacks_Callbacks); - /*--- Wrapped vars code ---*/ + /* "ssh/callbacks.pyx":63 + * self._cb.userdata = func + * + * def set_callbacks(self, Session session not None): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9callbacks_9Callbacks_7set_callbacks, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Callbacks_set_callbacks, NULL, __pyx_n_s_ssh_callbacks, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9callbacks_Callbacks, __pyx_n_s_set_callbacks, __pyx_t_2) < 0) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9callbacks_Callbacks); + + /* "(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_3ssh_9callbacks_9Callbacks_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Callbacks___reduce_cython, NULL, __pyx_n_s_ssh_callbacks, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9callbacks_9Callbacks_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Callbacks___setstate_cython, NULL, __pyx_n_s_ssh_callbacks, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "ssh/callbacks.pyx":1 + * # This file is part of ssh-python. # <<<<<<<<<<<<<< + * # Copyright (C) 2018 Panos Kittenis + * # + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init ssh.callbacks", __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 ssh.callbacks"); } @@ -2629,6 +4302,22 @@ if (!__Pyx_RefNanny) { return; #endif } +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ @@ -2648,6 +4337,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { @@ -2662,10 +4453,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject } #endif +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); @@ -2677,7 +4497,7 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { } /* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; @@ -2706,7 +4526,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args --tstate->recursion_depth; return result; } -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); @@ -2722,9 +4541,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } + #endif if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && @@ -2793,7 +4618,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, return result; } #endif -#endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON @@ -2802,8 +4626,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -2820,10 +4649,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -2835,98 +4669,91 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject } #endif -/* PyObjectCallNoArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} #endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) -#endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) return __Pyx_PyObject_CallMethO(func, NULL); - } } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); -} -#endif - -/* PyCFunctionFastCall */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + 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 - -/* PyObjectCallOneArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); } -#endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (__Pyx_PyFastCFunction_Check(func)) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); } + #endif } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif } -#endif /* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; @@ -2938,21 +4765,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; - #else + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; - #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); + #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; @@ -2973,31 +4825,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); -} -#endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + #endif } #endif @@ -3008,20 +4836,32 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { - PyObject *local_type, *local_value, *local_tb; + PyObject *local_type = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } + #else local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; + #endif #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) @@ -3043,12 +4883,21 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; + #endif } #else tmp_type = tstate->exc_type; @@ -3075,72 +4924,231 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) return -1; } -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } } -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; } #endif -/* WriteUnraisableException */ -static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, - CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, - int full_traceback, CYTHON_UNUSED int nogil) { - PyObject *old_exc, *old_val, *old_tb; - PyObject *ctx; - __Pyx_PyThreadState_declare -#ifdef WITH_THREAD - PyGILState_STATE state; - if (nogil) - state = PyGILState_Ensure(); -#ifdef _MSC_VER - else state = (PyGILState_STATE)-1; +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } #endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; #endif - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); - if (full_traceback) { - Py_XINCREF(old_exc); - Py_XINCREF(old_val); - Py_XINCREF(old_tb); - __Pyx_ErrRestore(old_exc, old_val, old_tb); - PyErr_PrintEx(1); + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; } - #if PY_MAJOR_VERSION < 3 - ctx = PyString_FromString(name); - #else - ctx = PyUnicode_FromString(name); - #endif - __Pyx_ErrRestore(old_exc, old_val, old_tb); - if (!ctx) { - PyErr_WriteUnraisable(Py_None); + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; } else { - PyErr_WriteUnraisable(ctx); - Py_DECREF(ctx); + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; } -#ifdef WITH_THREAD - if (nogil) - PyGILState_Release(state); +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); #endif } +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + Py_XDECREF(key); + Py_XDECREF(value); + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; @@ -3222,17 +5436,21 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); return 0; } /* RaiseException */ #if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); Py_XINCREF(type); if (!value || value == Py_None) value = NULL; @@ -3365,13 +5583,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } PyErr_SetObject(type, value); if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else + #if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { @@ -3379,6 +5593,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); #endif } bad: @@ -3387,89 +5607,439 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } #endif -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + type->tp_print = (printfunc) memb->offset; #endif - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; + changed = 1; + } +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; } + if (changed) + PyType_Modified(type); } - return descr; +#endif + return 0; } #endif -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -#endif -/* PyObjectGetAttrStrNoError */ -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif #endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + { + 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; + } + } } - return result; -} - -/* SetupReduce */ -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } @@ -3529,7 +6099,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); @@ -3545,8 +6115,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } goto __PYX_GOOD; __PYX_BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP @@ -3562,67 +6137,1264 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { Py_XDECREF(setstate_cython); return ret; } +#endif /* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; -#ifdef Py_LIMITED_API + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; + PyObject *py_itemsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#if !CYTHON_COMPILING_IN_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize+itemsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } -#ifndef Py_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; + return def->ml_meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; -#endif - if ((size_t)basicsize < size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); } #endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), +#endif + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -3652,12 +7424,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -3671,7 +7444,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -3693,6 +7466,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -3771,17 +7545,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -3816,6 +7674,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -3831,7 +7690,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -3878,6 +7737,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -3914,7 +7774,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -3928,40 +7788,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -3974,109 +7839,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -4130,10 +8067,52 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__9); } + return name; } +#endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { @@ -4168,8 +8147,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -4186,7 +8191,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -4200,40 +8205,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -4246,109 +8256,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -4373,7 +8455,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -4394,6 +8476,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -4418,11 +8516,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -4470,47 +8568,56 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionImport */ -#ifndef __PYX_HAVE_RT_ImportFunction -#define __PYX_HAVE_RT_ImportFunction -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { +#ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { @@ -4527,7 +8634,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** PyModule_GetName(module), funcname); goto bad; } -#if PY_VERSION_HEX >= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", @@ -4535,21 +8641,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); -#else - {const char *desc, *s1, *s2; - desc = (const char *)PyCObject_GetDesc(cobj); - if (!desc) - goto bad; - s1 = desc; s2 = sig; - while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } - if (*s1 != *s2) { - PyErr_Format(PyExc_TypeError, - "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", - PyModule_GetName(module), funcname, sig, desc); - goto bad; - } - tmp.p = PyCObject_AsVoidPtr(cobj);} -#endif *f = tmp.fp; if (!(*f)) goto bad; @@ -4562,9 +8653,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** #endif /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -4572,30 +8685,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -4650,7 +8767,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -4679,22 +8796,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -4760,13 +8881,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -4834,4 +8953,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/channel.c b/ssh/channel.c index 224eeb19..f895b522 100644 --- a/ssh/channel.c +++ b/ssh/channel.c @@ -1,22 +1,72 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.channel", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/channel.pyx" + ] + }, + "module_name": "ssh.channel" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +85,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +93,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +130,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +150,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +278,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +307,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +318,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +341,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +368,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +392,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +476,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +500,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +517,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +579,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +614,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; - } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +766,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +783,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +873,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +919,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +953,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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)) + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1047,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1062,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1104,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1121,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1168,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1188,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1228,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -795,9 +1306,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -815,9 +1327,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -825,13 +1337,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -855,10 +1361,56 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; @@ -877,7 +1429,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -907,6 +1459,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -942,25 +1495,28 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "ssh/channel.pyx", - "stringsource", + "", "ssh/channel.pxd", "ssh/session.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -968,11 +1524,9 @@ static const char *__pyx_f[] = { #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_3ssh_7session_Session; @@ -1022,6 +1576,7 @@ struct __pyx_vtabstruct_3ssh_7channel_Channel { struct __pyx_obj_3ssh_7channel_Channel *(*from_ptr)(ssh_channel, struct __pyx_obj_3ssh_7session_Session *); }; static struct __pyx_vtabstruct_3ssh_7channel_Channel *__pyx_vtabptr_3ssh_7channel_Channel; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1030,11 +1585,11 @@ static struct __pyx_vtabstruct_3ssh_7channel_Channel *__pyx_vtabptr_3ssh_7channe #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1044,28 +1599,40 @@ static struct __pyx_vtabstruct_3ssh_7channel_Channel *__pyx_vtabptr_3ssh_7channe #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1076,6 +1643,10 @@ static struct __pyx_vtabstruct_3ssh_7channel_Channel *__pyx_vtabptr_3ssh_7channe #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);\ @@ -1087,43 +1658,30 @@ static struct __pyx_vtabstruct_3ssh_7channel_Channel *__pyx_vtabptr_3ssh_7channe #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ - const char* function_name); - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); - /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1135,7 +1693,7 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1151,6 +1709,105 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) @@ -1168,7 +1825,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, #endif /* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif @@ -1186,6 +1843,49 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#endif +#endif + /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); @@ -1193,6 +1893,35 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); @@ -1208,33 +1937,180 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 }; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif #endif +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1269,6 +2145,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1282,13 +2159,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif @@ -1304,6 +2182,19 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1313,133 +2204,222 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionImport.proto */ -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ static struct __pyx_obj_3ssh_7channel_Channel *__pyx_f_3ssh_7channel_7Channel_from_ptr(ssh_channel __pyx_v__chan, struct __pyx_obj_3ssh_7session_Session *__pyx_v_session); /* proto*/ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "libc.time" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'ssh.session' */ -static PyTypeObject *__pyx_ptype_3ssh_7session_Session = 0; +/* Module declarations from "ssh.session" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'libc.stdlib' */ +/* Module declarations from "libc.stdlib" */ -/* Module declarations from 'ssh.utils' */ +/* Module declarations from "ssh.utils" */ static PyObject *(*__pyx_f_3ssh_5utils_to_bytes)(PyObject *); /*proto*/ static PyObject *(*__pyx_f_3ssh_5utils_to_str)(char const *); /*proto*/ static int (*__pyx_f_3ssh_5utils_handle_error_codes)(int, ssh_session); /*proto*/ -/* Module declarations from 'ssh.channel' */ -static PyTypeObject *__pyx_ptype_3ssh_7channel_Channel = 0; +/* Module declarations from "ssh.channel" */ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.channel" extern int __pyx_module_is_main_ssh__channel; int __pyx_module_is_main_ssh__channel = 0; -/* Implementation of 'ssh.channel' */ +/* Implementation of "ssh.channel" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_NotImplementedError; static PyObject *__pyx_builtin_TypeError; +/* #### Code section: string_decls ### */ static const char __pyx_k_[] = ""; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_rc[] = "rc"; +static const char __pyx_k__66[] = "?"; +static const char __pyx_k_buf[] = "buf"; +static const char __pyx_k_cmd[] = "cmd"; static const char __pyx_k_col[] = "col"; static const char __pyx_k_row[] = "row"; +static const char __pyx_k_sig[] = "sig"; +static const char __pyx_k_cbuf[] = "cbuf"; +static const char __pyx_k_chan[] = "chan"; static const char __pyx_k_cols[] = "cols"; +static const char __pyx_k_data[] = "data"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "name"; +static const char __pyx_k_poll[] = "poll"; +static const char __pyx_k_read[] = "read"; static const char __pyx_k_rows[] = "rows"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_size[] = "size"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_b_buf[] = "b_buf"; +static const char __pyx_k_b_cmd[] = "b_cmd"; +static const char __pyx_k_b_sig[] = "b_sig"; +static const char __pyx_k_b_sys[] = "b_sys"; +static const char __pyx_k_buf_2[] = "_buf"; +static const char __pyx_k_c_cmd[] = "c_cmd"; +static const char __pyx_k_c_sig[] = "c_sig"; +static const char __pyx_k_c_sys[] = "c_sys"; +static const char __pyx_k_close[] = "close"; static const char __pyx_k_maxfd[] = "maxfd"; static const char __pyx_k_value[] = "value"; +static const char __pyx_k_write[] = "write"; +static const char __pyx_k_b_name[] = "b_name"; +static const char __pyx_k_c_name[] = "c_name"; +static const char __pyx_k_chan_2[] = "_chan"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_is_eof[] = "is_eof"; +static const char __pyx_k_length[] = "length"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_select[] = "select"; static const char __pyx_k_Channel[] = "Channel"; +static const char __pyx_k_b_value[] = "b_value"; +static const char __pyx_k_c_value[] = "c_value"; +static const char __pyx_k_counter[] = "counter"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_is_open[] = "is_open"; static const char __pyx_k_readfds[] = "readfds"; static const char __pyx_k_session[] = "session"; static const char __pyx_k_timeout[] = "timeout"; +static const char __pyx_k_blocking[] = "blocking"; static const char __pyx_k_channels[] = "channels"; static const char __pyx_k_getstate[] = "__getstate__"; +static const char __pyx_k_open_x11[] = "open_x11"; +static const char __pyx_k_send_eof[] = "send_eof"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_terminal[] = "terminal"; static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_is_closed[] = "is_closed"; static const char __pyx_k_is_stderr[] = "is_stderr"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_subsystem[] = "subsystem"; +static const char __pyx_k_accept_x11[] = "accept_x11"; +static const char __pyx_k_b_terminal[] = "b_terminal"; +static const char __pyx_k_c_terminal[] = "c_terminal"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_remotehost[] = "remotehost"; static const char __pyx_k_remoteport[] = "remoteport"; static const char __pyx_k_sourcehost[] = "sourcehost"; static const char __pyx_k_sourceport[] = "sourceport"; +static const char __pyx_k_timeout_ms[] = "timeout_ms"; static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_get_session[] = "get_session"; static const char __pyx_k_outchannels[] = "outchannels"; +static const char __pyx_k_request_env[] = "request_env"; +static const char __pyx_k_request_pty[] = "request_pty"; +static const char __pyx_k_request_x11[] = "request_x11"; +static const char __pyx_k_set_counter[] = "set_counter"; +static const char __pyx_k_ssh_channel[] = "ssh.channel"; +static const char __pyx_k_window_size[] = "window_size"; +static const char __pyx_k_Channel_poll[] = "Channel.poll"; +static const char __pyx_k_Channel_read[] = "Channel.read"; +static const char __pyx_k_b_remotehost[] = "b_remotehost"; +static const char __pyx_k_b_sourcehost[] = "b_sourcehost"; +static const char __pyx_k_buf_tot_size[] = "buf_tot_size"; +static const char __pyx_k_c_remotehost[] = "c_remotehost"; +static const char __pyx_k_c_sourcehost[] = "c_sourcehost"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_open_forward[] = "open_forward"; +static const char __pyx_k_open_session[] = "open_session"; +static const char __pyx_k_poll_timeout[] = "poll_timeout"; +static const char __pyx_k_read_timeout[] = "read_timeout"; +static const char __pyx_k_request_exec[] = "request_exec"; +static const char __pyx_k_request_sftp[] = "request_sftp"; +static const char __pyx_k_set_blocking[] = "set_blocking"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_write_stderr[] = "write_stderr"; +static const char __pyx_k_Channel_close[] = "Channel.close"; +static const char __pyx_k_Channel_write[] = "Channel.write"; +static const char __pyx_k_buf_remainder[] = "buf_remainder"; +static const char __pyx_k_bytes_written[] = "bytes_written"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_request_shell[] = "request_shell"; static const char __pyx_k_screen_number[] = "screen_number"; +static const char __pyx_k_Channel_is_eof[] = "Channel.is_eof"; +static const char __pyx_k_Channel_select[] = "Channel.select"; +static const char __pyx_k_Channel_is_open[] = "Channel.is_open"; +static const char __pyx_k_change_pty_size[] = "change_pty_size"; +static const char __pyx_k_get_exit_status[] = "get_exit_status"; +static const char __pyx_k_open_auth_agent[] = "open_auth_agent"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_ssh_channel_pyx[] = "ssh/channel.pyx"; +static const char __pyx_k_Channel_open_x11[] = "Channel.open_x11"; +static const char __pyx_k_Channel_send_eof[] = "Channel.send_eof"; +static const char __pyx_k_read_nonblocking[] = "read_nonblocking"; +static const char __pyx_k_request_pty_size[] = "request_pty_size"; +static const char __pyx_k_Channel_is_closed[] = "Channel.is_closed"; +static const char __pyx_k_request_subsystem[] = "request_subsystem"; static const char __pyx_k_single_connection[] = "single_connection"; +static const char __pyx_k_Channel_accept_x11[] = "Channel.accept_x11"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_request_auth_agent[] = "request_auth_agent"; +static const char __pyx_k_request_send_break[] = "request_send_break"; +static const char __pyx_k_Channel_get_session[] = "Channel.get_session"; +static const char __pyx_k_Channel_request_env[] = "Channel.request_env"; +static const char __pyx_k_Channel_request_pty[] = "Channel.request_pty"; +static const char __pyx_k_Channel_request_x11[] = "Channel.request_x11"; +static const char __pyx_k_Channel_set_counter[] = "Channel.set_counter"; +static const char __pyx_k_Channel_window_size[] = "Channel.window_size"; static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; +static const char __pyx_k_request_send_signal[] = "request_send_signal"; +static const char __pyx_k_Channel_open_forward[] = "Channel.open_forward"; +static const char __pyx_k_Channel_open_session[] = "Channel.open_session"; +static const char __pyx_k_Channel_poll_timeout[] = "Channel.poll_timeout"; +static const char __pyx_k_Channel_read_timeout[] = "Channel.read_timeout"; +static const char __pyx_k_Channel_request_exec[] = "Channel.request_exec"; +static const char __pyx_k_Channel_request_sftp[] = "Channel.request_sftp"; +static const char __pyx_k_Channel_set_blocking[] = "Channel.set_blocking"; +static const char __pyx_k_Channel_write_stderr[] = "Channel.write_stderr"; +static const char __pyx_k_Channel_request_shell[] = "Channel.request_shell"; +static const char __pyx_k_Channel___reduce_cython[] = "Channel.__reduce_cython__"; +static const char __pyx_k_Channel_change_pty_size[] = "Channel.change_pty_size"; +static const char __pyx_k_Channel_get_exit_status[] = "Channel.get_exit_status"; +static const char __pyx_k_Channel_open_auth_agent[] = "Channel.open_auth_agent"; +static const char __pyx_k_Channel_read_nonblocking[] = "Channel.read_nonblocking"; +static const char __pyx_k_Channel_request_pty_size[] = "Channel.request_pty_size"; +static const char __pyx_k_Channel___setstate_cython[] = "Channel.__setstate_cython__"; +static const char __pyx_k_Channel_request_subsystem[] = "Channel.request_subsystem"; +static const char __pyx_k_Channel_request_auth_agent[] = "Channel.request_auth_agent"; +static const char __pyx_k_Channel_request_send_break[] = "Channel.request_send_break"; +static const char __pyx_k_Channel_request_send_signal[] = "Channel.request_send_signal"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static PyObject *__pyx_kp_b_; -static PyObject *__pyx_n_s_Channel; -static PyObject *__pyx_n_s_MemoryError; -static PyObject *__pyx_n_s_NotImplementedError; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_n_s_channels; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_col; -static PyObject *__pyx_n_s_cols; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_is_stderr; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_maxfd; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_name_2; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_n_s_outchannels; -static PyObject *__pyx_n_s_pyx_vtable; -static PyObject *__pyx_n_s_readfds; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_remotehost; -static PyObject *__pyx_n_s_remoteport; -static PyObject *__pyx_n_s_row; -static PyObject *__pyx_n_s_rows; -static PyObject *__pyx_n_s_screen_number; -static PyObject *__pyx_n_s_session; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_single_connection; -static PyObject *__pyx_n_s_size; -static PyObject *__pyx_n_s_sourcehost; -static PyObject *__pyx_n_s_sourceport; -static PyObject *__pyx_n_s_terminal; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_timeout; -static PyObject *__pyx_n_s_value; +/* #### Code section: decls ### */ static int __pyx_pf_3ssh_7channel_7Channel___cinit__(struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self, struct __pyx_obj_3ssh_7session_Session *__pyx_v_session); /* proto */ static void __pyx_pf_3ssh_7channel_7Channel_2__dealloc__(struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_7channel_7Channel_7session___get__(struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self); /* proto */ @@ -1482,10 +2462,1060 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_6closed___get__(struct __pyx_ob static PyObject *__pyx_pf_3ssh_7channel_7Channel_74__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_7channel_7Channel_76__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_3ssh_7channel_Channel(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_int_0; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -/* Late includes */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_3ssh_7session_Session; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_3ssh_7channel_Channel; + #endif + PyTypeObject *__pyx_ptype_3ssh_7channel_Channel; + PyObject *__pyx_kp_b_; + PyObject *__pyx_n_s_Channel; + PyObject *__pyx_n_s_Channel___reduce_cython; + PyObject *__pyx_n_s_Channel___setstate_cython; + PyObject *__pyx_n_s_Channel_accept_x11; + PyObject *__pyx_n_s_Channel_change_pty_size; + PyObject *__pyx_n_s_Channel_close; + PyObject *__pyx_n_s_Channel_get_exit_status; + PyObject *__pyx_n_s_Channel_get_session; + PyObject *__pyx_n_s_Channel_is_closed; + PyObject *__pyx_n_s_Channel_is_eof; + PyObject *__pyx_n_s_Channel_is_open; + PyObject *__pyx_n_s_Channel_open_auth_agent; + PyObject *__pyx_n_s_Channel_open_forward; + PyObject *__pyx_n_s_Channel_open_session; + PyObject *__pyx_n_s_Channel_open_x11; + PyObject *__pyx_n_s_Channel_poll; + PyObject *__pyx_n_s_Channel_poll_timeout; + PyObject *__pyx_n_s_Channel_read; + PyObject *__pyx_n_s_Channel_read_nonblocking; + PyObject *__pyx_n_s_Channel_read_timeout; + PyObject *__pyx_n_s_Channel_request_auth_agent; + PyObject *__pyx_n_s_Channel_request_env; + PyObject *__pyx_n_s_Channel_request_exec; + PyObject *__pyx_n_s_Channel_request_pty; + PyObject *__pyx_n_s_Channel_request_pty_size; + PyObject *__pyx_n_s_Channel_request_send_break; + PyObject *__pyx_n_s_Channel_request_send_signal; + PyObject *__pyx_n_s_Channel_request_sftp; + PyObject *__pyx_n_s_Channel_request_shell; + PyObject *__pyx_n_s_Channel_request_subsystem; + PyObject *__pyx_n_s_Channel_request_x11; + PyObject *__pyx_n_s_Channel_select; + PyObject *__pyx_n_s_Channel_send_eof; + PyObject *__pyx_n_s_Channel_set_blocking; + PyObject *__pyx_n_s_Channel_set_counter; + PyObject *__pyx_n_s_Channel_window_size; + PyObject *__pyx_n_s_Channel_write; + PyObject *__pyx_n_s_Channel_write_stderr; + PyObject *__pyx_n_s_MemoryError; + PyObject *__pyx_n_s_NotImplementedError; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s__66; + PyObject *__pyx_n_s_accept_x11; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_b_buf; + PyObject *__pyx_n_s_b_cmd; + PyObject *__pyx_n_s_b_name; + PyObject *__pyx_n_s_b_remotehost; + PyObject *__pyx_n_s_b_sig; + PyObject *__pyx_n_s_b_sourcehost; + PyObject *__pyx_n_s_b_sys; + PyObject *__pyx_n_s_b_terminal; + PyObject *__pyx_n_s_b_value; + PyObject *__pyx_n_s_blocking; + PyObject *__pyx_n_s_buf; + PyObject *__pyx_n_s_buf_2; + PyObject *__pyx_n_s_buf_remainder; + PyObject *__pyx_n_s_buf_tot_size; + PyObject *__pyx_n_s_bytes_written; + PyObject *__pyx_n_s_c_cmd; + PyObject *__pyx_n_s_c_name; + PyObject *__pyx_n_s_c_remotehost; + PyObject *__pyx_n_s_c_sig; + PyObject *__pyx_n_s_c_sourcehost; + PyObject *__pyx_n_s_c_sys; + PyObject *__pyx_n_s_c_terminal; + PyObject *__pyx_n_s_c_value; + PyObject *__pyx_n_s_cbuf; + PyObject *__pyx_n_s_chan; + PyObject *__pyx_n_s_chan_2; + PyObject *__pyx_n_s_change_pty_size; + PyObject *__pyx_n_s_channels; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_close; + PyObject *__pyx_n_s_cmd; + PyObject *__pyx_n_s_col; + PyObject *__pyx_n_s_cols; + PyObject *__pyx_n_s_counter; + PyObject *__pyx_n_s_data; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_get_exit_status; + PyObject *__pyx_n_s_get_session; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_is_closed; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_n_s_is_eof; + PyObject *__pyx_n_s_is_open; + PyObject *__pyx_n_s_is_stderr; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_length; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_maxfd; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_name_2; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_open_auth_agent; + PyObject *__pyx_n_s_open_forward; + PyObject *__pyx_n_s_open_session; + PyObject *__pyx_n_s_open_x11; + PyObject *__pyx_n_s_outchannels; + PyObject *__pyx_n_s_poll; + PyObject *__pyx_n_s_poll_timeout; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_rc; + PyObject *__pyx_n_s_read; + PyObject *__pyx_n_s_read_nonblocking; + PyObject *__pyx_n_s_read_timeout; + PyObject *__pyx_n_s_readfds; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_remotehost; + PyObject *__pyx_n_s_remoteport; + PyObject *__pyx_n_s_request_auth_agent; + PyObject *__pyx_n_s_request_env; + PyObject *__pyx_n_s_request_exec; + PyObject *__pyx_n_s_request_pty; + PyObject *__pyx_n_s_request_pty_size; + PyObject *__pyx_n_s_request_send_break; + PyObject *__pyx_n_s_request_send_signal; + PyObject *__pyx_n_s_request_sftp; + PyObject *__pyx_n_s_request_shell; + PyObject *__pyx_n_s_request_subsystem; + PyObject *__pyx_n_s_request_x11; + PyObject *__pyx_n_s_row; + PyObject *__pyx_n_s_rows; + PyObject *__pyx_n_s_screen_number; + PyObject *__pyx_n_s_select; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_send_eof; + PyObject *__pyx_n_s_session; + PyObject *__pyx_n_s_set_blocking; + PyObject *__pyx_n_s_set_counter; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_sig; + PyObject *__pyx_n_s_single_connection; + PyObject *__pyx_n_s_size; + PyObject *__pyx_n_s_sourcehost; + PyObject *__pyx_n_s_sourceport; + PyObject *__pyx_n_s_ssh_channel; + PyObject *__pyx_kp_s_ssh_channel_pyx; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_subsystem; + PyObject *__pyx_n_s_terminal; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_timeout; + PyObject *__pyx_n_s_timeout_ms; + PyObject *__pyx_n_s_value; + PyObject *__pyx_n_s_window_size; + PyObject *__pyx_n_s_write; + PyObject *__pyx_n_s_write_stderr; + PyObject *__pyx_int_0; + PyObject *__pyx_int_1048576; + PyObject *__pyx_tuple__2; + PyObject *__pyx_tuple__5; + PyObject *__pyx_tuple__13; + PyObject *__pyx_tuple__16; + PyObject *__pyx_tuple__18; + PyObject *__pyx_tuple__20; + PyObject *__pyx_tuple__22; + PyObject *__pyx_tuple__23; + PyObject *__pyx_tuple__25; + PyObject *__pyx_tuple__27; + PyObject *__pyx_tuple__29; + PyObject *__pyx_tuple__31; + PyObject *__pyx_tuple__33; + PyObject *__pyx_tuple__36; + PyObject *__pyx_tuple__38; + PyObject *__pyx_tuple__40; + PyObject *__pyx_tuple__42; + PyObject *__pyx_tuple__46; + PyObject *__pyx_tuple__48; + PyObject *__pyx_tuple__50; + PyObject *__pyx_tuple__51; + PyObject *__pyx_tuple__53; + PyObject *__pyx_tuple__55; + PyObject *__pyx_tuple__58; + PyObject *__pyx_tuple__60; + PyObject *__pyx_tuple__62; + PyObject *__pyx_tuple__64; + PyObject *__pyx_codeobj__3; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__6; + PyObject *__pyx_codeobj__7; + PyObject *__pyx_codeobj__8; + PyObject *__pyx_codeobj__9; + PyObject *__pyx_codeobj__10; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__12; + PyObject *__pyx_codeobj__14; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__17; + PyObject *__pyx_codeobj__19; + PyObject *__pyx_codeobj__21; + PyObject *__pyx_codeobj__24; + PyObject *__pyx_codeobj__26; + PyObject *__pyx_codeobj__28; + PyObject *__pyx_codeobj__30; + PyObject *__pyx_codeobj__32; + PyObject *__pyx_codeobj__34; + PyObject *__pyx_codeobj__35; + PyObject *__pyx_codeobj__37; + PyObject *__pyx_codeobj__39; + PyObject *__pyx_codeobj__41; + PyObject *__pyx_codeobj__43; + PyObject *__pyx_codeobj__44; + PyObject *__pyx_codeobj__45; + PyObject *__pyx_codeobj__47; + PyObject *__pyx_codeobj__49; + PyObject *__pyx_codeobj__52; + PyObject *__pyx_codeobj__54; + PyObject *__pyx_codeobj__56; + PyObject *__pyx_codeobj__57; + PyObject *__pyx_codeobj__59; + PyObject *__pyx_codeobj__61; + PyObject *__pyx_codeobj__63; + PyObject *__pyx_codeobj__65; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_7session_Session); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_7channel_Channel); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_7channel_Channel); + Py_CLEAR(clear_module_state->__pyx_kp_b_); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_accept_x11); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_change_pty_size); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_close); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_get_exit_status); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_get_session); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_is_closed); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_is_eof); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_is_open); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_open_auth_agent); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_open_forward); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_open_session); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_open_x11); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_poll); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_poll_timeout); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_read); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_read_nonblocking); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_read_timeout); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_auth_agent); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_env); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_exec); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_pty); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_pty_size); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_send_break); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_send_signal); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_sftp); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_shell); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_subsystem); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_x11); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_select); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_send_eof); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_set_blocking); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_set_counter); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_window_size); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_write); + Py_CLEAR(clear_module_state->__pyx_n_s_Channel_write_stderr); + Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); + Py_CLEAR(clear_module_state->__pyx_n_s_NotImplementedError); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s__66); + Py_CLEAR(clear_module_state->__pyx_n_s_accept_x11); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_b_buf); + Py_CLEAR(clear_module_state->__pyx_n_s_b_cmd); + Py_CLEAR(clear_module_state->__pyx_n_s_b_name); + Py_CLEAR(clear_module_state->__pyx_n_s_b_remotehost); + Py_CLEAR(clear_module_state->__pyx_n_s_b_sig); + Py_CLEAR(clear_module_state->__pyx_n_s_b_sourcehost); + Py_CLEAR(clear_module_state->__pyx_n_s_b_sys); + Py_CLEAR(clear_module_state->__pyx_n_s_b_terminal); + Py_CLEAR(clear_module_state->__pyx_n_s_b_value); + Py_CLEAR(clear_module_state->__pyx_n_s_blocking); + Py_CLEAR(clear_module_state->__pyx_n_s_buf); + Py_CLEAR(clear_module_state->__pyx_n_s_buf_2); + Py_CLEAR(clear_module_state->__pyx_n_s_buf_remainder); + Py_CLEAR(clear_module_state->__pyx_n_s_buf_tot_size); + Py_CLEAR(clear_module_state->__pyx_n_s_bytes_written); + Py_CLEAR(clear_module_state->__pyx_n_s_c_cmd); + Py_CLEAR(clear_module_state->__pyx_n_s_c_name); + Py_CLEAR(clear_module_state->__pyx_n_s_c_remotehost); + Py_CLEAR(clear_module_state->__pyx_n_s_c_sig); + Py_CLEAR(clear_module_state->__pyx_n_s_c_sourcehost); + Py_CLEAR(clear_module_state->__pyx_n_s_c_sys); + Py_CLEAR(clear_module_state->__pyx_n_s_c_terminal); + Py_CLEAR(clear_module_state->__pyx_n_s_c_value); + Py_CLEAR(clear_module_state->__pyx_n_s_cbuf); + Py_CLEAR(clear_module_state->__pyx_n_s_chan); + Py_CLEAR(clear_module_state->__pyx_n_s_chan_2); + Py_CLEAR(clear_module_state->__pyx_n_s_change_pty_size); + Py_CLEAR(clear_module_state->__pyx_n_s_channels); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_close); + Py_CLEAR(clear_module_state->__pyx_n_s_cmd); + Py_CLEAR(clear_module_state->__pyx_n_s_col); + Py_CLEAR(clear_module_state->__pyx_n_s_cols); + Py_CLEAR(clear_module_state->__pyx_n_s_counter); + Py_CLEAR(clear_module_state->__pyx_n_s_data); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_get_exit_status); + Py_CLEAR(clear_module_state->__pyx_n_s_get_session); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_is_closed); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_n_s_is_eof); + Py_CLEAR(clear_module_state->__pyx_n_s_is_open); + Py_CLEAR(clear_module_state->__pyx_n_s_is_stderr); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_length); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_maxfd); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_name_2); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_open_auth_agent); + Py_CLEAR(clear_module_state->__pyx_n_s_open_forward); + Py_CLEAR(clear_module_state->__pyx_n_s_open_session); + Py_CLEAR(clear_module_state->__pyx_n_s_open_x11); + Py_CLEAR(clear_module_state->__pyx_n_s_outchannels); + Py_CLEAR(clear_module_state->__pyx_n_s_poll); + Py_CLEAR(clear_module_state->__pyx_n_s_poll_timeout); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_rc); + Py_CLEAR(clear_module_state->__pyx_n_s_read); + Py_CLEAR(clear_module_state->__pyx_n_s_read_nonblocking); + Py_CLEAR(clear_module_state->__pyx_n_s_read_timeout); + Py_CLEAR(clear_module_state->__pyx_n_s_readfds); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_remotehost); + Py_CLEAR(clear_module_state->__pyx_n_s_remoteport); + Py_CLEAR(clear_module_state->__pyx_n_s_request_auth_agent); + Py_CLEAR(clear_module_state->__pyx_n_s_request_env); + Py_CLEAR(clear_module_state->__pyx_n_s_request_exec); + Py_CLEAR(clear_module_state->__pyx_n_s_request_pty); + Py_CLEAR(clear_module_state->__pyx_n_s_request_pty_size); + Py_CLEAR(clear_module_state->__pyx_n_s_request_send_break); + Py_CLEAR(clear_module_state->__pyx_n_s_request_send_signal); + Py_CLEAR(clear_module_state->__pyx_n_s_request_sftp); + Py_CLEAR(clear_module_state->__pyx_n_s_request_shell); + Py_CLEAR(clear_module_state->__pyx_n_s_request_subsystem); + Py_CLEAR(clear_module_state->__pyx_n_s_request_x11); + Py_CLEAR(clear_module_state->__pyx_n_s_row); + Py_CLEAR(clear_module_state->__pyx_n_s_rows); + Py_CLEAR(clear_module_state->__pyx_n_s_screen_number); + Py_CLEAR(clear_module_state->__pyx_n_s_select); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_send_eof); + Py_CLEAR(clear_module_state->__pyx_n_s_session); + Py_CLEAR(clear_module_state->__pyx_n_s_set_blocking); + Py_CLEAR(clear_module_state->__pyx_n_s_set_counter); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_sig); + Py_CLEAR(clear_module_state->__pyx_n_s_single_connection); + Py_CLEAR(clear_module_state->__pyx_n_s_size); + Py_CLEAR(clear_module_state->__pyx_n_s_sourcehost); + Py_CLEAR(clear_module_state->__pyx_n_s_sourceport); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_channel); + Py_CLEAR(clear_module_state->__pyx_kp_s_ssh_channel_pyx); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_subsystem); + Py_CLEAR(clear_module_state->__pyx_n_s_terminal); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_timeout); + Py_CLEAR(clear_module_state->__pyx_n_s_timeout_ms); + Py_CLEAR(clear_module_state->__pyx_n_s_value); + Py_CLEAR(clear_module_state->__pyx_n_s_window_size); + Py_CLEAR(clear_module_state->__pyx_n_s_write); + Py_CLEAR(clear_module_state->__pyx_n_s_write_stderr); + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_1048576); + Py_CLEAR(clear_module_state->__pyx_tuple__2); + Py_CLEAR(clear_module_state->__pyx_tuple__5); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_tuple__18); + Py_CLEAR(clear_module_state->__pyx_tuple__20); + Py_CLEAR(clear_module_state->__pyx_tuple__22); + Py_CLEAR(clear_module_state->__pyx_tuple__23); + Py_CLEAR(clear_module_state->__pyx_tuple__25); + Py_CLEAR(clear_module_state->__pyx_tuple__27); + Py_CLEAR(clear_module_state->__pyx_tuple__29); + Py_CLEAR(clear_module_state->__pyx_tuple__31); + Py_CLEAR(clear_module_state->__pyx_tuple__33); + Py_CLEAR(clear_module_state->__pyx_tuple__36); + Py_CLEAR(clear_module_state->__pyx_tuple__38); + Py_CLEAR(clear_module_state->__pyx_tuple__40); + Py_CLEAR(clear_module_state->__pyx_tuple__42); + Py_CLEAR(clear_module_state->__pyx_tuple__46); + Py_CLEAR(clear_module_state->__pyx_tuple__48); + Py_CLEAR(clear_module_state->__pyx_tuple__50); + Py_CLEAR(clear_module_state->__pyx_tuple__51); + Py_CLEAR(clear_module_state->__pyx_tuple__53); + Py_CLEAR(clear_module_state->__pyx_tuple__55); + Py_CLEAR(clear_module_state->__pyx_tuple__58); + Py_CLEAR(clear_module_state->__pyx_tuple__60); + Py_CLEAR(clear_module_state->__pyx_tuple__62); + Py_CLEAR(clear_module_state->__pyx_tuple__64); + Py_CLEAR(clear_module_state->__pyx_codeobj__3); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__6); + Py_CLEAR(clear_module_state->__pyx_codeobj__7); + Py_CLEAR(clear_module_state->__pyx_codeobj__8); + Py_CLEAR(clear_module_state->__pyx_codeobj__9); + Py_CLEAR(clear_module_state->__pyx_codeobj__10); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__12); + Py_CLEAR(clear_module_state->__pyx_codeobj__14); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + Py_CLEAR(clear_module_state->__pyx_codeobj__19); + Py_CLEAR(clear_module_state->__pyx_codeobj__21); + Py_CLEAR(clear_module_state->__pyx_codeobj__24); + Py_CLEAR(clear_module_state->__pyx_codeobj__26); + Py_CLEAR(clear_module_state->__pyx_codeobj__28); + Py_CLEAR(clear_module_state->__pyx_codeobj__30); + Py_CLEAR(clear_module_state->__pyx_codeobj__32); + Py_CLEAR(clear_module_state->__pyx_codeobj__34); + Py_CLEAR(clear_module_state->__pyx_codeobj__35); + Py_CLEAR(clear_module_state->__pyx_codeobj__37); + Py_CLEAR(clear_module_state->__pyx_codeobj__39); + Py_CLEAR(clear_module_state->__pyx_codeobj__41); + Py_CLEAR(clear_module_state->__pyx_codeobj__43); + Py_CLEAR(clear_module_state->__pyx_codeobj__44); + Py_CLEAR(clear_module_state->__pyx_codeobj__45); + Py_CLEAR(clear_module_state->__pyx_codeobj__47); + Py_CLEAR(clear_module_state->__pyx_codeobj__49); + Py_CLEAR(clear_module_state->__pyx_codeobj__52); + Py_CLEAR(clear_module_state->__pyx_codeobj__54); + Py_CLEAR(clear_module_state->__pyx_codeobj__56); + Py_CLEAR(clear_module_state->__pyx_codeobj__57); + Py_CLEAR(clear_module_state->__pyx_codeobj__59); + Py_CLEAR(clear_module_state->__pyx_codeobj__61); + Py_CLEAR(clear_module_state->__pyx_codeobj__63); + Py_CLEAR(clear_module_state->__pyx_codeobj__65); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_7session_Session); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_7channel_Channel); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_7channel_Channel); + Py_VISIT(traverse_module_state->__pyx_kp_b_); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_accept_x11); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_change_pty_size); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_close); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_get_exit_status); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_get_session); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_is_closed); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_is_eof); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_is_open); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_open_auth_agent); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_open_forward); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_open_session); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_open_x11); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_poll); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_poll_timeout); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_read); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_read_nonblocking); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_read_timeout); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_auth_agent); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_env); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_exec); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_pty); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_pty_size); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_send_break); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_send_signal); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_sftp); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_shell); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_subsystem); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_x11); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_select); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_send_eof); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_set_blocking); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_set_counter); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_window_size); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_write); + Py_VISIT(traverse_module_state->__pyx_n_s_Channel_write_stderr); + Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); + Py_VISIT(traverse_module_state->__pyx_n_s_NotImplementedError); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s__66); + Py_VISIT(traverse_module_state->__pyx_n_s_accept_x11); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_b_buf); + Py_VISIT(traverse_module_state->__pyx_n_s_b_cmd); + Py_VISIT(traverse_module_state->__pyx_n_s_b_name); + Py_VISIT(traverse_module_state->__pyx_n_s_b_remotehost); + Py_VISIT(traverse_module_state->__pyx_n_s_b_sig); + Py_VISIT(traverse_module_state->__pyx_n_s_b_sourcehost); + Py_VISIT(traverse_module_state->__pyx_n_s_b_sys); + Py_VISIT(traverse_module_state->__pyx_n_s_b_terminal); + Py_VISIT(traverse_module_state->__pyx_n_s_b_value); + Py_VISIT(traverse_module_state->__pyx_n_s_blocking); + Py_VISIT(traverse_module_state->__pyx_n_s_buf); + Py_VISIT(traverse_module_state->__pyx_n_s_buf_2); + Py_VISIT(traverse_module_state->__pyx_n_s_buf_remainder); + Py_VISIT(traverse_module_state->__pyx_n_s_buf_tot_size); + Py_VISIT(traverse_module_state->__pyx_n_s_bytes_written); + Py_VISIT(traverse_module_state->__pyx_n_s_c_cmd); + Py_VISIT(traverse_module_state->__pyx_n_s_c_name); + Py_VISIT(traverse_module_state->__pyx_n_s_c_remotehost); + Py_VISIT(traverse_module_state->__pyx_n_s_c_sig); + Py_VISIT(traverse_module_state->__pyx_n_s_c_sourcehost); + Py_VISIT(traverse_module_state->__pyx_n_s_c_sys); + Py_VISIT(traverse_module_state->__pyx_n_s_c_terminal); + Py_VISIT(traverse_module_state->__pyx_n_s_c_value); + Py_VISIT(traverse_module_state->__pyx_n_s_cbuf); + Py_VISIT(traverse_module_state->__pyx_n_s_chan); + Py_VISIT(traverse_module_state->__pyx_n_s_chan_2); + Py_VISIT(traverse_module_state->__pyx_n_s_change_pty_size); + Py_VISIT(traverse_module_state->__pyx_n_s_channels); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_close); + Py_VISIT(traverse_module_state->__pyx_n_s_cmd); + Py_VISIT(traverse_module_state->__pyx_n_s_col); + Py_VISIT(traverse_module_state->__pyx_n_s_cols); + Py_VISIT(traverse_module_state->__pyx_n_s_counter); + Py_VISIT(traverse_module_state->__pyx_n_s_data); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_get_exit_status); + Py_VISIT(traverse_module_state->__pyx_n_s_get_session); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_is_closed); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_n_s_is_eof); + Py_VISIT(traverse_module_state->__pyx_n_s_is_open); + Py_VISIT(traverse_module_state->__pyx_n_s_is_stderr); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_length); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_maxfd); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_name_2); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_open_auth_agent); + Py_VISIT(traverse_module_state->__pyx_n_s_open_forward); + Py_VISIT(traverse_module_state->__pyx_n_s_open_session); + Py_VISIT(traverse_module_state->__pyx_n_s_open_x11); + Py_VISIT(traverse_module_state->__pyx_n_s_outchannels); + Py_VISIT(traverse_module_state->__pyx_n_s_poll); + Py_VISIT(traverse_module_state->__pyx_n_s_poll_timeout); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_rc); + Py_VISIT(traverse_module_state->__pyx_n_s_read); + Py_VISIT(traverse_module_state->__pyx_n_s_read_nonblocking); + Py_VISIT(traverse_module_state->__pyx_n_s_read_timeout); + Py_VISIT(traverse_module_state->__pyx_n_s_readfds); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_remotehost); + Py_VISIT(traverse_module_state->__pyx_n_s_remoteport); + Py_VISIT(traverse_module_state->__pyx_n_s_request_auth_agent); + Py_VISIT(traverse_module_state->__pyx_n_s_request_env); + Py_VISIT(traverse_module_state->__pyx_n_s_request_exec); + Py_VISIT(traverse_module_state->__pyx_n_s_request_pty); + Py_VISIT(traverse_module_state->__pyx_n_s_request_pty_size); + Py_VISIT(traverse_module_state->__pyx_n_s_request_send_break); + Py_VISIT(traverse_module_state->__pyx_n_s_request_send_signal); + Py_VISIT(traverse_module_state->__pyx_n_s_request_sftp); + Py_VISIT(traverse_module_state->__pyx_n_s_request_shell); + Py_VISIT(traverse_module_state->__pyx_n_s_request_subsystem); + Py_VISIT(traverse_module_state->__pyx_n_s_request_x11); + Py_VISIT(traverse_module_state->__pyx_n_s_row); + Py_VISIT(traverse_module_state->__pyx_n_s_rows); + Py_VISIT(traverse_module_state->__pyx_n_s_screen_number); + Py_VISIT(traverse_module_state->__pyx_n_s_select); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_send_eof); + Py_VISIT(traverse_module_state->__pyx_n_s_session); + Py_VISIT(traverse_module_state->__pyx_n_s_set_blocking); + Py_VISIT(traverse_module_state->__pyx_n_s_set_counter); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_sig); + Py_VISIT(traverse_module_state->__pyx_n_s_single_connection); + Py_VISIT(traverse_module_state->__pyx_n_s_size); + Py_VISIT(traverse_module_state->__pyx_n_s_sourcehost); + Py_VISIT(traverse_module_state->__pyx_n_s_sourceport); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_channel); + Py_VISIT(traverse_module_state->__pyx_kp_s_ssh_channel_pyx); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_subsystem); + Py_VISIT(traverse_module_state->__pyx_n_s_terminal); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_timeout); + Py_VISIT(traverse_module_state->__pyx_n_s_timeout_ms); + Py_VISIT(traverse_module_state->__pyx_n_s_value); + Py_VISIT(traverse_module_state->__pyx_n_s_window_size); + Py_VISIT(traverse_module_state->__pyx_n_s_write); + Py_VISIT(traverse_module_state->__pyx_n_s_write_stderr); + Py_VISIT(traverse_module_state->__pyx_int_0); + Py_VISIT(traverse_module_state->__pyx_int_1048576); + Py_VISIT(traverse_module_state->__pyx_tuple__2); + Py_VISIT(traverse_module_state->__pyx_tuple__5); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_tuple__18); + Py_VISIT(traverse_module_state->__pyx_tuple__20); + Py_VISIT(traverse_module_state->__pyx_tuple__22); + Py_VISIT(traverse_module_state->__pyx_tuple__23); + Py_VISIT(traverse_module_state->__pyx_tuple__25); + Py_VISIT(traverse_module_state->__pyx_tuple__27); + Py_VISIT(traverse_module_state->__pyx_tuple__29); + Py_VISIT(traverse_module_state->__pyx_tuple__31); + Py_VISIT(traverse_module_state->__pyx_tuple__33); + Py_VISIT(traverse_module_state->__pyx_tuple__36); + Py_VISIT(traverse_module_state->__pyx_tuple__38); + Py_VISIT(traverse_module_state->__pyx_tuple__40); + Py_VISIT(traverse_module_state->__pyx_tuple__42); + Py_VISIT(traverse_module_state->__pyx_tuple__46); + Py_VISIT(traverse_module_state->__pyx_tuple__48); + Py_VISIT(traverse_module_state->__pyx_tuple__50); + Py_VISIT(traverse_module_state->__pyx_tuple__51); + Py_VISIT(traverse_module_state->__pyx_tuple__53); + Py_VISIT(traverse_module_state->__pyx_tuple__55); + Py_VISIT(traverse_module_state->__pyx_tuple__58); + Py_VISIT(traverse_module_state->__pyx_tuple__60); + Py_VISIT(traverse_module_state->__pyx_tuple__62); + Py_VISIT(traverse_module_state->__pyx_tuple__64); + Py_VISIT(traverse_module_state->__pyx_codeobj__3); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__6); + Py_VISIT(traverse_module_state->__pyx_codeobj__7); + Py_VISIT(traverse_module_state->__pyx_codeobj__8); + Py_VISIT(traverse_module_state->__pyx_codeobj__9); + Py_VISIT(traverse_module_state->__pyx_codeobj__10); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__12); + Py_VISIT(traverse_module_state->__pyx_codeobj__14); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + Py_VISIT(traverse_module_state->__pyx_codeobj__19); + Py_VISIT(traverse_module_state->__pyx_codeobj__21); + Py_VISIT(traverse_module_state->__pyx_codeobj__24); + Py_VISIT(traverse_module_state->__pyx_codeobj__26); + Py_VISIT(traverse_module_state->__pyx_codeobj__28); + Py_VISIT(traverse_module_state->__pyx_codeobj__30); + Py_VISIT(traverse_module_state->__pyx_codeobj__32); + Py_VISIT(traverse_module_state->__pyx_codeobj__34); + Py_VISIT(traverse_module_state->__pyx_codeobj__35); + Py_VISIT(traverse_module_state->__pyx_codeobj__37); + Py_VISIT(traverse_module_state->__pyx_codeobj__39); + Py_VISIT(traverse_module_state->__pyx_codeobj__41); + Py_VISIT(traverse_module_state->__pyx_codeobj__43); + Py_VISIT(traverse_module_state->__pyx_codeobj__44); + Py_VISIT(traverse_module_state->__pyx_codeobj__45); + Py_VISIT(traverse_module_state->__pyx_codeobj__47); + Py_VISIT(traverse_module_state->__pyx_codeobj__49); + Py_VISIT(traverse_module_state->__pyx_codeobj__52); + Py_VISIT(traverse_module_state->__pyx_codeobj__54); + Py_VISIT(traverse_module_state->__pyx_codeobj__56); + Py_VISIT(traverse_module_state->__pyx_codeobj__57); + Py_VISIT(traverse_module_state->__pyx_codeobj__59); + Py_VISIT(traverse_module_state->__pyx_codeobj__61); + Py_VISIT(traverse_module_state->__pyx_codeobj__63); + Py_VISIT(traverse_module_state->__pyx_codeobj__65); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_3ssh_7session_Session __pyx_mstate_global->__pyx_ptype_3ssh_7session_Session +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_3ssh_7channel_Channel __pyx_mstate_global->__pyx_type_3ssh_7channel_Channel +#endif +#define __pyx_ptype_3ssh_7channel_Channel __pyx_mstate_global->__pyx_ptype_3ssh_7channel_Channel +#define __pyx_kp_b_ __pyx_mstate_global->__pyx_kp_b_ +#define __pyx_n_s_Channel __pyx_mstate_global->__pyx_n_s_Channel +#define __pyx_n_s_Channel___reduce_cython __pyx_mstate_global->__pyx_n_s_Channel___reduce_cython +#define __pyx_n_s_Channel___setstate_cython __pyx_mstate_global->__pyx_n_s_Channel___setstate_cython +#define __pyx_n_s_Channel_accept_x11 __pyx_mstate_global->__pyx_n_s_Channel_accept_x11 +#define __pyx_n_s_Channel_change_pty_size __pyx_mstate_global->__pyx_n_s_Channel_change_pty_size +#define __pyx_n_s_Channel_close __pyx_mstate_global->__pyx_n_s_Channel_close +#define __pyx_n_s_Channel_get_exit_status __pyx_mstate_global->__pyx_n_s_Channel_get_exit_status +#define __pyx_n_s_Channel_get_session __pyx_mstate_global->__pyx_n_s_Channel_get_session +#define __pyx_n_s_Channel_is_closed __pyx_mstate_global->__pyx_n_s_Channel_is_closed +#define __pyx_n_s_Channel_is_eof __pyx_mstate_global->__pyx_n_s_Channel_is_eof +#define __pyx_n_s_Channel_is_open __pyx_mstate_global->__pyx_n_s_Channel_is_open +#define __pyx_n_s_Channel_open_auth_agent __pyx_mstate_global->__pyx_n_s_Channel_open_auth_agent +#define __pyx_n_s_Channel_open_forward __pyx_mstate_global->__pyx_n_s_Channel_open_forward +#define __pyx_n_s_Channel_open_session __pyx_mstate_global->__pyx_n_s_Channel_open_session +#define __pyx_n_s_Channel_open_x11 __pyx_mstate_global->__pyx_n_s_Channel_open_x11 +#define __pyx_n_s_Channel_poll __pyx_mstate_global->__pyx_n_s_Channel_poll +#define __pyx_n_s_Channel_poll_timeout __pyx_mstate_global->__pyx_n_s_Channel_poll_timeout +#define __pyx_n_s_Channel_read __pyx_mstate_global->__pyx_n_s_Channel_read +#define __pyx_n_s_Channel_read_nonblocking __pyx_mstate_global->__pyx_n_s_Channel_read_nonblocking +#define __pyx_n_s_Channel_read_timeout __pyx_mstate_global->__pyx_n_s_Channel_read_timeout +#define __pyx_n_s_Channel_request_auth_agent __pyx_mstate_global->__pyx_n_s_Channel_request_auth_agent +#define __pyx_n_s_Channel_request_env __pyx_mstate_global->__pyx_n_s_Channel_request_env +#define __pyx_n_s_Channel_request_exec __pyx_mstate_global->__pyx_n_s_Channel_request_exec +#define __pyx_n_s_Channel_request_pty __pyx_mstate_global->__pyx_n_s_Channel_request_pty +#define __pyx_n_s_Channel_request_pty_size __pyx_mstate_global->__pyx_n_s_Channel_request_pty_size +#define __pyx_n_s_Channel_request_send_break __pyx_mstate_global->__pyx_n_s_Channel_request_send_break +#define __pyx_n_s_Channel_request_send_signal __pyx_mstate_global->__pyx_n_s_Channel_request_send_signal +#define __pyx_n_s_Channel_request_sftp __pyx_mstate_global->__pyx_n_s_Channel_request_sftp +#define __pyx_n_s_Channel_request_shell __pyx_mstate_global->__pyx_n_s_Channel_request_shell +#define __pyx_n_s_Channel_request_subsystem __pyx_mstate_global->__pyx_n_s_Channel_request_subsystem +#define __pyx_n_s_Channel_request_x11 __pyx_mstate_global->__pyx_n_s_Channel_request_x11 +#define __pyx_n_s_Channel_select __pyx_mstate_global->__pyx_n_s_Channel_select +#define __pyx_n_s_Channel_send_eof __pyx_mstate_global->__pyx_n_s_Channel_send_eof +#define __pyx_n_s_Channel_set_blocking __pyx_mstate_global->__pyx_n_s_Channel_set_blocking +#define __pyx_n_s_Channel_set_counter __pyx_mstate_global->__pyx_n_s_Channel_set_counter +#define __pyx_n_s_Channel_window_size __pyx_mstate_global->__pyx_n_s_Channel_window_size +#define __pyx_n_s_Channel_write __pyx_mstate_global->__pyx_n_s_Channel_write +#define __pyx_n_s_Channel_write_stderr __pyx_mstate_global->__pyx_n_s_Channel_write_stderr +#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError +#define __pyx_n_s_NotImplementedError __pyx_mstate_global->__pyx_n_s_NotImplementedError +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s__66 __pyx_mstate_global->__pyx_n_s__66 +#define __pyx_n_s_accept_x11 __pyx_mstate_global->__pyx_n_s_accept_x11 +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_b_buf __pyx_mstate_global->__pyx_n_s_b_buf +#define __pyx_n_s_b_cmd __pyx_mstate_global->__pyx_n_s_b_cmd +#define __pyx_n_s_b_name __pyx_mstate_global->__pyx_n_s_b_name +#define __pyx_n_s_b_remotehost __pyx_mstate_global->__pyx_n_s_b_remotehost +#define __pyx_n_s_b_sig __pyx_mstate_global->__pyx_n_s_b_sig +#define __pyx_n_s_b_sourcehost __pyx_mstate_global->__pyx_n_s_b_sourcehost +#define __pyx_n_s_b_sys __pyx_mstate_global->__pyx_n_s_b_sys +#define __pyx_n_s_b_terminal __pyx_mstate_global->__pyx_n_s_b_terminal +#define __pyx_n_s_b_value __pyx_mstate_global->__pyx_n_s_b_value +#define __pyx_n_s_blocking __pyx_mstate_global->__pyx_n_s_blocking +#define __pyx_n_s_buf __pyx_mstate_global->__pyx_n_s_buf +#define __pyx_n_s_buf_2 __pyx_mstate_global->__pyx_n_s_buf_2 +#define __pyx_n_s_buf_remainder __pyx_mstate_global->__pyx_n_s_buf_remainder +#define __pyx_n_s_buf_tot_size __pyx_mstate_global->__pyx_n_s_buf_tot_size +#define __pyx_n_s_bytes_written __pyx_mstate_global->__pyx_n_s_bytes_written +#define __pyx_n_s_c_cmd __pyx_mstate_global->__pyx_n_s_c_cmd +#define __pyx_n_s_c_name __pyx_mstate_global->__pyx_n_s_c_name +#define __pyx_n_s_c_remotehost __pyx_mstate_global->__pyx_n_s_c_remotehost +#define __pyx_n_s_c_sig __pyx_mstate_global->__pyx_n_s_c_sig +#define __pyx_n_s_c_sourcehost __pyx_mstate_global->__pyx_n_s_c_sourcehost +#define __pyx_n_s_c_sys __pyx_mstate_global->__pyx_n_s_c_sys +#define __pyx_n_s_c_terminal __pyx_mstate_global->__pyx_n_s_c_terminal +#define __pyx_n_s_c_value __pyx_mstate_global->__pyx_n_s_c_value +#define __pyx_n_s_cbuf __pyx_mstate_global->__pyx_n_s_cbuf +#define __pyx_n_s_chan __pyx_mstate_global->__pyx_n_s_chan +#define __pyx_n_s_chan_2 __pyx_mstate_global->__pyx_n_s_chan_2 +#define __pyx_n_s_change_pty_size __pyx_mstate_global->__pyx_n_s_change_pty_size +#define __pyx_n_s_channels __pyx_mstate_global->__pyx_n_s_channels +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close +#define __pyx_n_s_cmd __pyx_mstate_global->__pyx_n_s_cmd +#define __pyx_n_s_col __pyx_mstate_global->__pyx_n_s_col +#define __pyx_n_s_cols __pyx_mstate_global->__pyx_n_s_cols +#define __pyx_n_s_counter __pyx_mstate_global->__pyx_n_s_counter +#define __pyx_n_s_data __pyx_mstate_global->__pyx_n_s_data +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_get_exit_status __pyx_mstate_global->__pyx_n_s_get_exit_status +#define __pyx_n_s_get_session __pyx_mstate_global->__pyx_n_s_get_session +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_is_closed __pyx_mstate_global->__pyx_n_s_is_closed +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_n_s_is_eof __pyx_mstate_global->__pyx_n_s_is_eof +#define __pyx_n_s_is_open __pyx_mstate_global->__pyx_n_s_is_open +#define __pyx_n_s_is_stderr __pyx_mstate_global->__pyx_n_s_is_stderr +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_length __pyx_mstate_global->__pyx_n_s_length +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_maxfd __pyx_mstate_global->__pyx_n_s_maxfd +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_open_auth_agent __pyx_mstate_global->__pyx_n_s_open_auth_agent +#define __pyx_n_s_open_forward __pyx_mstate_global->__pyx_n_s_open_forward +#define __pyx_n_s_open_session __pyx_mstate_global->__pyx_n_s_open_session +#define __pyx_n_s_open_x11 __pyx_mstate_global->__pyx_n_s_open_x11 +#define __pyx_n_s_outchannels __pyx_mstate_global->__pyx_n_s_outchannels +#define __pyx_n_s_poll __pyx_mstate_global->__pyx_n_s_poll +#define __pyx_n_s_poll_timeout __pyx_mstate_global->__pyx_n_s_poll_timeout +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc +#define __pyx_n_s_read __pyx_mstate_global->__pyx_n_s_read +#define __pyx_n_s_read_nonblocking __pyx_mstate_global->__pyx_n_s_read_nonblocking +#define __pyx_n_s_read_timeout __pyx_mstate_global->__pyx_n_s_read_timeout +#define __pyx_n_s_readfds __pyx_mstate_global->__pyx_n_s_readfds +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_remotehost __pyx_mstate_global->__pyx_n_s_remotehost +#define __pyx_n_s_remoteport __pyx_mstate_global->__pyx_n_s_remoteport +#define __pyx_n_s_request_auth_agent __pyx_mstate_global->__pyx_n_s_request_auth_agent +#define __pyx_n_s_request_env __pyx_mstate_global->__pyx_n_s_request_env +#define __pyx_n_s_request_exec __pyx_mstate_global->__pyx_n_s_request_exec +#define __pyx_n_s_request_pty __pyx_mstate_global->__pyx_n_s_request_pty +#define __pyx_n_s_request_pty_size __pyx_mstate_global->__pyx_n_s_request_pty_size +#define __pyx_n_s_request_send_break __pyx_mstate_global->__pyx_n_s_request_send_break +#define __pyx_n_s_request_send_signal __pyx_mstate_global->__pyx_n_s_request_send_signal +#define __pyx_n_s_request_sftp __pyx_mstate_global->__pyx_n_s_request_sftp +#define __pyx_n_s_request_shell __pyx_mstate_global->__pyx_n_s_request_shell +#define __pyx_n_s_request_subsystem __pyx_mstate_global->__pyx_n_s_request_subsystem +#define __pyx_n_s_request_x11 __pyx_mstate_global->__pyx_n_s_request_x11 +#define __pyx_n_s_row __pyx_mstate_global->__pyx_n_s_row +#define __pyx_n_s_rows __pyx_mstate_global->__pyx_n_s_rows +#define __pyx_n_s_screen_number __pyx_mstate_global->__pyx_n_s_screen_number +#define __pyx_n_s_select __pyx_mstate_global->__pyx_n_s_select +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_send_eof __pyx_mstate_global->__pyx_n_s_send_eof +#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session +#define __pyx_n_s_set_blocking __pyx_mstate_global->__pyx_n_s_set_blocking +#define __pyx_n_s_set_counter __pyx_mstate_global->__pyx_n_s_set_counter +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_sig __pyx_mstate_global->__pyx_n_s_sig +#define __pyx_n_s_single_connection __pyx_mstate_global->__pyx_n_s_single_connection +#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size +#define __pyx_n_s_sourcehost __pyx_mstate_global->__pyx_n_s_sourcehost +#define __pyx_n_s_sourceport __pyx_mstate_global->__pyx_n_s_sourceport +#define __pyx_n_s_ssh_channel __pyx_mstate_global->__pyx_n_s_ssh_channel +#define __pyx_kp_s_ssh_channel_pyx __pyx_mstate_global->__pyx_kp_s_ssh_channel_pyx +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_subsystem __pyx_mstate_global->__pyx_n_s_subsystem +#define __pyx_n_s_terminal __pyx_mstate_global->__pyx_n_s_terminal +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_timeout __pyx_mstate_global->__pyx_n_s_timeout +#define __pyx_n_s_timeout_ms __pyx_mstate_global->__pyx_n_s_timeout_ms +#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value +#define __pyx_n_s_window_size __pyx_mstate_global->__pyx_n_s_window_size +#define __pyx_n_s_write __pyx_mstate_global->__pyx_n_s_write +#define __pyx_n_s_write_stderr __pyx_mstate_global->__pyx_n_s_write_stderr +#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 +#define __pyx_int_1048576 __pyx_mstate_global->__pyx_int_1048576 +#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 +#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 +#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 +#define __pyx_tuple__22 __pyx_mstate_global->__pyx_tuple__22 +#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23 +#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25 +#define __pyx_tuple__27 __pyx_mstate_global->__pyx_tuple__27 +#define __pyx_tuple__29 __pyx_mstate_global->__pyx_tuple__29 +#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31 +#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33 +#define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 +#define __pyx_tuple__38 __pyx_mstate_global->__pyx_tuple__38 +#define __pyx_tuple__40 __pyx_mstate_global->__pyx_tuple__40 +#define __pyx_tuple__42 __pyx_mstate_global->__pyx_tuple__42 +#define __pyx_tuple__46 __pyx_mstate_global->__pyx_tuple__46 +#define __pyx_tuple__48 __pyx_mstate_global->__pyx_tuple__48 +#define __pyx_tuple__50 __pyx_mstate_global->__pyx_tuple__50 +#define __pyx_tuple__51 __pyx_mstate_global->__pyx_tuple__51 +#define __pyx_tuple__53 __pyx_mstate_global->__pyx_tuple__53 +#define __pyx_tuple__55 __pyx_mstate_global->__pyx_tuple__55 +#define __pyx_tuple__58 __pyx_mstate_global->__pyx_tuple__58 +#define __pyx_tuple__60 __pyx_mstate_global->__pyx_tuple__60 +#define __pyx_tuple__62 __pyx_mstate_global->__pyx_tuple__62 +#define __pyx_tuple__64 __pyx_mstate_global->__pyx_tuple__64 +#define __pyx_codeobj__3 __pyx_mstate_global->__pyx_codeobj__3 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 +#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 +#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8 +#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9 +#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12 +#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 +#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 +#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 +#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26 +#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28 +#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30 +#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32 +#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34 +#define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 +#define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 +#define __pyx_codeobj__39 __pyx_mstate_global->__pyx_codeobj__39 +#define __pyx_codeobj__41 __pyx_mstate_global->__pyx_codeobj__41 +#define __pyx_codeobj__43 __pyx_mstate_global->__pyx_codeobj__43 +#define __pyx_codeobj__44 __pyx_mstate_global->__pyx_codeobj__44 +#define __pyx_codeobj__45 __pyx_mstate_global->__pyx_codeobj__45 +#define __pyx_codeobj__47 __pyx_mstate_global->__pyx_codeobj__47 +#define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49 +#define __pyx_codeobj__52 __pyx_mstate_global->__pyx_codeobj__52 +#define __pyx_codeobj__54 __pyx_mstate_global->__pyx_codeobj__54 +#define __pyx_codeobj__56 __pyx_mstate_global->__pyx_codeobj__56 +#define __pyx_codeobj__57 __pyx_mstate_global->__pyx_codeobj__57 +#define __pyx_codeobj__59 __pyx_mstate_global->__pyx_codeobj__59 +#define __pyx_codeobj__61 __pyx_mstate_global->__pyx_codeobj__61 +#define __pyx_codeobj__63 __pyx_mstate_global->__pyx_codeobj__63 +#define __pyx_codeobj__65 __pyx_mstate_global->__pyx_codeobj__65 +/* #### Code section: module_code ### */ /* "ssh/channel.pyx":29 * cdef class Channel: @@ -1499,44 +3529,64 @@ static PyObject *__pyx_tuple__3; static int __pyx_pw_3ssh_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_3ssh_7session_Session *__pyx_v_session = 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("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 29, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 29, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 29, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_session = ((struct __pyx_obj_3ssh_7session_Session *)values[0]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 29, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 29, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -1549,6 +3599,12 @@ static int __pyx_pw_3ssh_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, Py __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1556,7 +3612,7 @@ static int __pyx_pw_3ssh_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, Py static int __pyx_pf_3ssh_7channel_7Channel___cinit__(struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self, struct __pyx_obj_3ssh_7session_Session *__pyx_v_session) { int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_RefNannySetupContext("__cinit__", 1); /* "ssh/channel.pyx":30 * @@ -1574,10 +3630,10 @@ static int __pyx_pf_3ssh_7channel_7Channel___cinit__(struct __pyx_obj_3ssh_7chan * * def __dealloc__(self): */ - __Pyx_INCREF(((PyObject *)__pyx_v_session)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_session)); - __Pyx_GOTREF(__pyx_v_self->_session); - __Pyx_DECREF(((PyObject *)__pyx_v_self->_session)); + __Pyx_INCREF((PyObject *)__pyx_v_session); + __Pyx_GIVEREF((PyObject *)__pyx_v_session); + __Pyx_GOTREF((PyObject *)__pyx_v_self->_session); + __Pyx_DECREF((PyObject *)__pyx_v_self->_session); __pyx_v_self->_session = __pyx_v_session; /* "ssh/channel.pyx":29 @@ -1605,8 +3661,10 @@ static int __pyx_pf_3ssh_7channel_7Channel___cinit__(struct __pyx_obj_3ssh_7chan /* Python wrapper */ static void __pyx_pw_3ssh_7channel_7Channel_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_3ssh_7channel_7Channel_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_3ssh_7channel_7Channel_2__dealloc__(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -1614,11 +3672,8 @@ static void __pyx_pw_3ssh_7channel_7Channel_3__dealloc__(PyObject *__pyx_v_self) } static void __pyx_pf_3ssh_7channel_7Channel_2__dealloc__(struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; - int __pyx_t_3; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "ssh/channel.pyx":34 * @@ -1627,15 +3682,14 @@ static void __pyx_pf_3ssh_7channel_7Channel_2__dealloc__(struct __pyx_obj_3ssh_7 * c_ssh.ssh_channel_free(self._channel) * self._channel = NULL */ - __pyx_t_2 = ((__pyx_v_self->_channel != NULL) != 0); + __pyx_t_2 = (__pyx_v_self->_channel != NULL); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (((PyObject *)__pyx_v_self->_session) != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { @@ -1675,23 +3729,24 @@ static void __pyx_pf_3ssh_7channel_7Channel_2__dealloc__(struct __pyx_obj_3ssh_7 */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } -/* "ssh/channel.pyx":39 +/* "ssh/channel.pyx":38 + * self._channel = NULL * - * @property - * def session(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def session(self): * """Originating session.""" - * return self._session */ /* Python wrapper */ static PyObject *__pyx_pw_3ssh_7channel_7Channel_7session_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_7channel_7Channel_7session_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_3ssh_7channel_7Channel_7session___get__(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -1702,7 +3757,7 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_7session_1__get__(PyObject *__p static PyObject *__pyx_pf_3ssh_7channel_7Channel_7session___get__(struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "ssh/channel.pyx":41 * def session(self): @@ -1712,16 +3767,16 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_7session___get__(struct __pyx_o * @staticmethod */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self->_session)); + __Pyx_INCREF((PyObject *)__pyx_v_self->_session); __pyx_r = ((PyObject *)__pyx_v_self->_session); goto __pyx_L0; - /* "ssh/channel.pyx":39 + /* "ssh/channel.pyx":38 + * self._channel = NULL * - * @property - * def session(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def session(self): * """Originating session.""" - * return self._session */ /* function exit code */ @@ -1748,7 +3803,7 @@ static struct __pyx_obj_3ssh_7channel_Channel *__pyx_f_3ssh_7channel_7Channel_fr int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("from_ptr", 0); + __Pyx_RefNannySetupContext("from_ptr", 1); /* "ssh/channel.pyx":45 * @staticmethod @@ -1759,11 +3814,11 @@ static struct __pyx_obj_3ssh_7channel_Channel *__pyx_f_3ssh_7channel_7Channel_fr */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)__pyx_v_session)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_session)); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session)); + __Pyx_INCREF((PyObject *)__pyx_v_session); + __Pyx_GIVEREF((PyObject *)__pyx_v_session); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(0, 45, __pyx_L1_error); __pyx_t_2 = ((PyObject *)__pyx_tp_new_3ssh_7channel_Channel(((PyTypeObject *)__pyx_ptype_3ssh_7channel_Channel), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_2)); + __Pyx_GOTREF((PyObject *)__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_chan = ((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_t_2); __pyx_t_2 = 0; @@ -1784,8 +3839,8 @@ static struct __pyx_obj_3ssh_7channel_Channel *__pyx_f_3ssh_7channel_7Channel_fr * * def close(self): */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v_chan)); + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_chan); __pyx_r = __pyx_v_chan; goto __pyx_L0; @@ -1819,12 +3874,40 @@ static struct __pyx_obj_3ssh_7channel_Channel *__pyx_f_3ssh_7channel_7Channel_fr */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_5close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_4close[] = "Channel.close(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_5close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_5close(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_4close, "Channel.close(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_5close = {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_5close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_4close}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_5close(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 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("close", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "close", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_4close(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -1842,7 +3925,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_4close(struct __pyx_obj_3ssh_7c int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("close", 0); + __Pyx_RefNannySetupContext("close", 1); /* "ssh/channel.pyx":51 * def close(self): @@ -1851,8 +3934,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_4close(struct __pyx_obj_3ssh_7c * return 0 * with nogil: */ - __pyx_t_1 = (__pyx_v_self->closed != 0); - if (__pyx_t_1) { + if (__pyx_v_self->closed) { /* "ssh/channel.pyx":52 * cdef int rc @@ -1885,6 +3967,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_4close(struct __pyx_obj_3ssh_7c { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -1926,7 +4009,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_4close(struct __pyx_obj_3ssh_7c * self.closed = True * return handle_error_codes(rc, self._session._session) */ - __pyx_t_1 = ((__pyx_v_rc == 0) != 0); + __pyx_t_1 = (__pyx_v_rc == 0); if (__pyx_t_1) { /* "ssh/channel.pyx":56 @@ -1990,12 +4073,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_4close(struct __pyx_obj_3ssh_7c */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_7get_exit_status(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_6get_exit_status[] = "Channel.get_exit_status(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_7get_exit_status(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_7get_exit_status(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_6get_exit_status, "Channel.get_exit_status(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_7get_exit_status = {"get_exit_status", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_7get_exit_status, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_6get_exit_status}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_7get_exit_status(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("get_exit_status (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("get_exit_status", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_exit_status", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_6get_exit_status(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2011,7 +4122,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_6get_exit_status(struct __pyx_o int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_exit_status", 0); + __Pyx_RefNannySetupContext("get_exit_status", 1); /* "ssh/channel.pyx":61 * def get_exit_status(self): @@ -2023,6 +4134,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_6get_exit_status(struct __pyx_o { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2099,12 +4211,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_6get_exit_status(struct __pyx_o */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_9get_session(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_8get_session[] = "Channel.get_session(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_9get_session(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_9get_session(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_8get_session, "Channel.get_session(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_9get_session = {"get_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_9get_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_8get_session}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_9get_session(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("get_session (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("get_session", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_session", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_8get_session(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2119,7 +4259,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_8get_session(struct __pyx_obj_3 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_session", 0); + __Pyx_RefNannySetupContext("get_session", 1); /* "ssh/channel.pyx":66 * @@ -2163,12 +4303,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_8get_session(struct __pyx_obj_3 */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_11is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_10is_closed[] = "Channel.is_closed(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_11is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_11is_closed(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_10is_closed, "Channel.is_closed(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_11is_closed = {"is_closed", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_11is_closed, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_10is_closed}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_11is_closed(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("is_closed (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("is_closed", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_closed", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_10is_closed(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2184,7 +4352,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_10is_closed(struct __pyx_obj_3s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_closed", 0); + __Pyx_RefNannySetupContext("is_closed", 1); /* "ssh/channel.pyx":70 * def is_closed(self): @@ -2196,6 +4364,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_10is_closed(struct __pyx_obj_3s { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2272,12 +4441,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_10is_closed(struct __pyx_obj_3s */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_13is_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_12is_eof[] = "Channel.is_eof(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_13is_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_13is_eof(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_12is_eof, "Channel.is_eof(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_13is_eof = {"is_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_13is_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_12is_eof}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_13is_eof(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("is_eof (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("is_eof", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_eof", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_12is_eof(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2294,7 +4491,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_12is_eof(struct __pyx_obj_3ssh_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_eof", 0); + __Pyx_RefNannySetupContext("is_eof", 1); /* "ssh/channel.pyx":76 * def is_eof(self): @@ -2306,6 +4503,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_12is_eof(struct __pyx_obj_3ssh_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2383,12 +4581,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_12is_eof(struct __pyx_obj_3ssh_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_15is_open(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_14is_open[] = "Channel.is_open(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_15is_open(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_15is_open(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_14is_open, "Channel.is_open(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_15is_open = {"is_open", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_15is_open, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_14is_open}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_15is_open(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("is_open (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("is_open", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_open", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_14is_open(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2405,7 +4631,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_14is_open(struct __pyx_obj_3ssh int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_open", 0); + __Pyx_RefNannySetupContext("is_open", 1); /* "ssh/channel.pyx":82 * def is_open(self): @@ -2417,6 +4643,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_14is_open(struct __pyx_obj_3ssh { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2494,12 +4721,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_14is_open(struct __pyx_obj_3ssh */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_17send_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_16send_eof[] = "Channel.send_eof(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_17send_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_17send_eof(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_16send_eof, "Channel.send_eof(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_17send_eof = {"send_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_17send_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_16send_eof}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_17send_eof(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("send_eof (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("send_eof", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "send_eof", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_16send_eof(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2516,7 +4771,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_16send_eof(struct __pyx_obj_3ss int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("send_eof", 0); + __Pyx_RefNannySetupContext("send_eof", 1); /* "ssh/channel.pyx":88 * def send_eof(self): @@ -2528,6 +4783,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_16send_eof(struct __pyx_obj_3ss { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2605,12 +4861,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_16send_eof(struct __pyx_obj_3ss */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_19request_auth_agent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_18request_auth_agent[] = "Channel.request_auth_agent(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_19request_auth_agent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_19request_auth_agent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_18request_auth_agent, "Channel.request_auth_agent(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_19request_auth_agent = {"request_auth_agent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_19request_auth_agent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_18request_auth_agent}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_19request_auth_agent(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("request_auth_agent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("request_auth_agent", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "request_auth_agent", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_18request_auth_agent(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2627,7 +4911,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_18request_auth_agent(struct __p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_auth_agent", 0); + __Pyx_RefNannySetupContext("request_auth_agent", 1); /* "ssh/channel.pyx":94 * def request_auth_agent(self): @@ -2639,6 +4923,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_18request_auth_agent(struct __p { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2716,12 +5001,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_18request_auth_agent(struct __p */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_21open_auth_agent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_20open_auth_agent[] = "Channel.open_auth_agent(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_21open_auth_agent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_21open_auth_agent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_20open_auth_agent, "Channel.open_auth_agent(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_21open_auth_agent = {"open_auth_agent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_21open_auth_agent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_20open_auth_agent}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_21open_auth_agent(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("open_auth_agent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("open_auth_agent", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "open_auth_agent", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_20open_auth_agent(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -2738,7 +5051,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_20open_auth_agent(struct __pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("open_auth_agent", 0); + __Pyx_RefNannySetupContext("open_auth_agent", 1); /* "ssh/channel.pyx":100 * def open_auth_agent(self): @@ -2750,6 +5063,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_20open_auth_agent(struct __pyx_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2827,81 +5141,130 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_20open_auth_agent(struct __pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_23open_forward(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_22open_forward[] = "Channel.open_forward(self, remotehost, int remoteport, sourcehost, int sourceport)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_23open_forward(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_23open_forward(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_22open_forward, "Channel.open_forward(self, remotehost, int remoteport, sourcehost, int sourceport)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_23open_forward = {"open_forward", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_23open_forward, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_22open_forward}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_23open_forward(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_remotehost = 0; int __pyx_v_remoteport; PyObject *__pyx_v_sourcehost = 0; int __pyx_v_sourceport; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("open_forward (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_remotehost,&__pyx_n_s_remoteport,&__pyx_n_s_sourcehost,&__pyx_n_s_sourceport,0}; - PyObject* values[4] = {0,0,0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_remotehost,&__pyx_n_s_remoteport,&__pyx_n_s_sourcehost,&__pyx_n_s_sourceport,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_remotehost)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_remotehost)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_remoteport)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_remoteport)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("open_forward", 1, 4, 4, 1); __PYX_ERR(0, 104, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sourcehost)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sourcehost)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("open_forward", 1, 4, 4, 2); __PYX_ERR(0, 104, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sourceport)) != 0)) kw_args--; + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sourceport)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("open_forward", 1, 4, 4, 3); __PYX_ERR(0, 104, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open_forward") < 0)) __PYX_ERR(0, 104, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "open_forward") < 0)) __PYX_ERR(0, 104, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_remotehost = values[0]; __pyx_v_remoteport = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_remoteport == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) __pyx_v_sourcehost = values[2]; __pyx_v_sourceport = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_sourceport == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 105, __pyx_L3_error) } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("open_forward", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 104, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("open_forward", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 104, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.open_forward", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -2909,6 +5272,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_23open_forward(PyObject *__pyx_ __pyx_r = __pyx_pf_3ssh_7channel_7Channel_22open_forward(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_remotehost, __pyx_v_remoteport, __pyx_v_sourcehost, __pyx_v_sourceport); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2927,7 +5296,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_22open_forward(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("open_forward", 0); + __Pyx_RefNannySetupContext("open_forward", 1); /* "ssh/channel.pyx":106 * def open_forward(self, remotehost, int remoteport, @@ -2991,6 +5360,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_22open_forward(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3070,12 +5440,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_22open_forward(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_25open_session(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_24open_session[] = "Channel.open_session(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_25open_session(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_25open_session(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_24open_session, "Channel.open_session(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_25open_session = {"open_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_25open_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_24open_session}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_25open_session(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("open_session (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("open_session", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "open_session", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_24open_session(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -3092,7 +5490,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_24open_session(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("open_session", 0); + __Pyx_RefNannySetupContext("open_session", 1); /* "ssh/channel.pyx":119 * def open_session(self): @@ -3104,6 +5502,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_24open_session(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3181,59 +5580,100 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_24open_session(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_27open_x11(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_26open_x11[] = "Channel.open_x11(self, sourcehost, int sourceport)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_27open_x11(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_27open_x11(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_26open_x11, "Channel.open_x11(self, sourcehost, int sourceport)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_27open_x11 = {"open_x11", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_27open_x11, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_26open_x11}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_27open_x11(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_sourcehost = 0; int __pyx_v_sourceport; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("open_x11 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sourcehost,&__pyx_n_s_sourceport,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sourcehost,&__pyx_n_s_sourceport,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sourcehost)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sourcehost)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 123, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sourceport)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sourceport)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 123, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("open_x11", 1, 2, 2, 1); __PYX_ERR(0, 123, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open_x11") < 0)) __PYX_ERR(0, 123, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "open_x11") < 0)) __PYX_ERR(0, 123, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_sourcehost = values[0]; __pyx_v_sourceport = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_sourceport == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 123, __pyx_L3_error) } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("open_x11", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 123, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("open_x11", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 123, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.open_x11", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3241,6 +5681,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_27open_x11(PyObject *__pyx_v_se __pyx_r = __pyx_pf_3ssh_7channel_7Channel_26open_x11(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_sourcehost, __pyx_v_sourceport); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3257,7 +5703,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_26open_x11(struct __pyx_obj_3ss int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("open_x11", 0); + __Pyx_RefNannySetupContext("open_x11", 1); /* "ssh/channel.pyx":124 * @@ -3295,6 +5741,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_26open_x11(struct __pyx_obj_3ss { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3373,28 +5820,98 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_26open_x11(struct __pyx_obj_3ss */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_29accept_x11(PyObject *__pyx_v_self, PyObject *__pyx_arg_timeout_ms); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_28accept_x11[] = "Channel.accept_x11(self, int timeout_ms)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_29accept_x11(PyObject *__pyx_v_self, PyObject *__pyx_arg_timeout_ms) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_29accept_x11(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_28accept_x11, "Channel.accept_x11(self, int timeout_ms)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_29accept_x11 = {"accept_x11", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_29accept_x11, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_28accept_x11}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_29accept_x11(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 +) { int __pyx_v_timeout_ms; + #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("accept_x11 (wrapper)", 0); - assert(__pyx_arg_timeout_ms); { - __pyx_v_timeout_ms = __Pyx_PyInt_As_int(__pyx_arg_timeout_ms); if (unlikely((__pyx_v_timeout_ms == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L3_error) + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout_ms,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout_ms)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "accept_x11") < 0)) __PYX_ERR(0, 132, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_timeout_ms = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_timeout_ms == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L3_error) } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("accept_x11", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 132, __pyx_L3_error) + __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.accept_x11", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_28accept_x11(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_timeout_ms)); + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_28accept_x11(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_timeout_ms); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3410,7 +5927,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_28accept_x11(struct __pyx_obj_3 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("accept_x11", 0); + __Pyx_RefNannySetupContext("accept_x11", 1); /* "ssh/channel.pyx":134 * def accept_x11(self, int timeout_ms): @@ -3431,6 +5948,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_28accept_x11(struct __pyx_obj_3 { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3472,7 +5990,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_28accept_x11(struct __pyx_obj_3 * raise MemoryError * chan = Channel.from_ptr(_chan, self._session) */ - __pyx_t_1 = ((__pyx_v__chan == NULL) != 0); + __pyx_t_1 = (__pyx_v__chan == NULL); if (unlikely(__pyx_t_1)) { /* "ssh/channel.pyx":138 @@ -3516,7 +6034,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_28accept_x11(struct __pyx_obj_3 * def poll(self, bint is_stderr=False): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_chan)); + __Pyx_INCREF((PyObject *)__pyx_v_chan); __pyx_r = ((PyObject *)__pyx_v_chan); goto __pyx_L0; @@ -3550,42 +6068,68 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_28accept_x11(struct __pyx_obj_3 */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_31poll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_30poll[] = "Channel.poll(self, bool is_stderr=False)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_31poll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_31poll(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_30poll, "Channel.poll(self, bool is_stderr=False)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_31poll = {"poll", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_31poll, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_30poll}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_31poll(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 +) { int __pyx_v_is_stderr; + #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("poll (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_is_stderr,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_is_stderr,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_is_stderr); - if (value) { values[0] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_is_stderr); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 142, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "poll") < 0)) __PYX_ERR(0, 142, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "poll") < 0)) __PYX_ERR(0, 142, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -3597,10 +6141,18 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_31poll(PyObject *__pyx_v_self, __pyx_v_is_stderr = ((int)0); } } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("poll", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 142, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("poll", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 142, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.poll", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3608,6 +6160,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_31poll(PyObject *__pyx_v_self, __pyx_r = __pyx_pf_3ssh_7channel_7Channel_30poll(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_is_stderr); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3621,7 +6179,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_30poll(struct __pyx_obj_3ssh_7c int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("poll", 0); + __Pyx_RefNannySetupContext("poll", 1); /* "ssh/channel.pyx":144 * def poll(self, bint is_stderr=False): @@ -3633,6 +6191,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_30poll(struct __pyx_obj_3ssh_7c { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3710,51 +6269,81 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_30poll(struct __pyx_obj_3ssh_7c */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_33poll_timeout(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_32poll_timeout[] = "Channel.poll_timeout(self, int timeout, bool is_stderr=False)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_33poll_timeout(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_33poll_timeout(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_32poll_timeout, "Channel.poll_timeout(self, int timeout, bool is_stderr=False)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_33poll_timeout = {"poll_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_33poll_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_32poll_timeout}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_33poll_timeout(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 +) { int __pyx_v_timeout; int __pyx_v_is_stderr; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("poll_timeout (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,&__pyx_n_s_is_stderr,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,&__pyx_n_s_is_stderr,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_is_stderr); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_is_stderr); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "poll_timeout") < 0)) __PYX_ERR(0, 148, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "poll_timeout") < 0)) __PYX_ERR(0, 148, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -3766,10 +6355,18 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_33poll_timeout(PyObject *__pyx_ __pyx_v_is_stderr = ((int)0); } } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("poll_timeout", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("poll_timeout", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 148, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.poll_timeout", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3777,6 +6374,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_33poll_timeout(PyObject *__pyx_ __pyx_r = __pyx_pf_3ssh_7channel_7Channel_32poll_timeout(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_timeout, __pyx_v_is_stderr); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3790,7 +6393,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_32poll_timeout(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("poll_timeout", 0); + __Pyx_RefNannySetupContext("poll_timeout", 1); /* "ssh/channel.pyx":150 * def poll_timeout(self, int timeout, bint is_stderr=False): @@ -3802,6 +6405,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_32poll_timeout(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3879,53 +6483,80 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_32poll_timeout(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_35read(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_34read[] = "Channel.read(self, uint32_t size=1048576, bool is_stderr=False)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_35read(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_35read(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_34read, "Channel.read(self, uint32_t size=0x100000, bool is_stderr=False)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_35read = {"read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_35read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_34read}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_35read(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 +) { uint32_t __pyx_v_size; int __pyx_v_is_stderr; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,&__pyx_n_s_is_stderr,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,&__pyx_n_s_is_stderr,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size); - if (value) { values[0] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_is_stderr); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_is_stderr); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read") < 0)) __PYX_ERR(0, 155, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "read") < 0)) __PYX_ERR(0, 155, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -3942,10 +6573,18 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_35read(PyObject *__pyx_v_self, __pyx_v_is_stderr = ((int)0); } } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("read", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 155, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("read", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 155, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.read", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3953,6 +6592,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_35read(PyObject *__pyx_v_self, __pyx_r = __pyx_pf_3ssh_7channel_7Channel_34read(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_size, __pyx_v_is_stderr); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3978,7 +6623,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_34read(struct __pyx_obj_3ssh_7c int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("read", 0); + __Pyx_RefNannySetupContext("read", 1); /* "ssh/channel.pyx":157 * def read(self, c_ssh.uint32_t size=1024*1024, bint is_stderr=False): @@ -4000,6 +6645,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_34read(struct __pyx_obj_3ssh_7c { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4021,8 +6667,8 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_34read(struct __pyx_obj_3ssh_7c * with gil: * raise MemoryError */ - __pyx_t_1 = ((__pyx_v_cbuf == NULL) != 0); - if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_cbuf == NULL); + if (unlikely(__pyx_t_1)) { /* "ssh/channel.pyx":162 * cbuf = malloc(sizeof(char)*size) @@ -4125,7 +6771,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_34read(struct __pyx_obj_3ssh_7c * buf = cbuf[:rc] * finally: */ - __pyx_t_1 = ((__pyx_v_rc > 0) != 0); + __pyx_t_1 = (__pyx_v_rc > 0); if (__pyx_t_1) { /* "ssh/channel.pyx":167 @@ -4211,10 +6857,10 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_34read(struct __pyx_obj_3ssh_7c __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error); __Pyx_INCREF(__pyx_v_buf); __Pyx_GIVEREF(__pyx_v_buf); - PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf)) __PYX_ERR(0, 170, __pyx_L1_error); __pyx_t_2 = 0; __pyx_r = __pyx_t_12; __pyx_t_12 = 0; @@ -4250,53 +6896,80 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_34read(struct __pyx_obj_3ssh_7c */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_36read_nonblocking[] = "Channel.read_nonblocking(self, uint32_t size=1048576, bool is_stderr=False)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_36read_nonblocking, "Channel.read_nonblocking(self, uint32_t size=0x100000, bool is_stderr=False)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_37read_nonblocking = {"read_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_36read_nonblocking}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking(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 +) { uint32_t __pyx_v_size; int __pyx_v_is_stderr; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read_nonblocking (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,&__pyx_n_s_is_stderr,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,&__pyx_n_s_is_stderr,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size); - if (value) { values[0] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 172, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_is_stderr); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_is_stderr); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 172, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_nonblocking") < 0)) __PYX_ERR(0, 172, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "read_nonblocking") < 0)) __PYX_ERR(0, 172, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -4321,10 +6994,18 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking(PyObject *__ __pyx_v_is_stderr = ((int)0); } } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("read_nonblocking", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 172, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("read_nonblocking", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 172, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.read_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -4340,6 +7021,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking(PyObject *__ */ /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4365,7 +7052,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_36read_nonblocking(struct __pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("read_nonblocking", 0); + __Pyx_RefNannySetupContext("read_nonblocking", 1); /* "ssh/channel.pyx":175 * bint is_stderr=False): @@ -4387,6 +7074,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_36read_nonblocking(struct __pyx { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4408,8 +7096,8 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_36read_nonblocking(struct __pyx * with gil: * raise MemoryError */ - __pyx_t_1 = ((__pyx_v_cbuf == NULL) != 0); - if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_cbuf == NULL); + if (unlikely(__pyx_t_1)) { /* "ssh/channel.pyx":180 * cbuf = malloc(sizeof(char)*size) @@ -4512,7 +7200,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_36read_nonblocking(struct __pyx * buf = cbuf[:rc] * finally: */ - __pyx_t_1 = ((__pyx_v_rc > 0) != 0); + __pyx_t_1 = (__pyx_v_rc > 0); if (__pyx_t_1) { /* "ssh/channel.pyx":186 @@ -4598,10 +7286,10 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_36read_nonblocking(struct __pyx __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error); __Pyx_INCREF(__pyx_v_buf); __Pyx_GIVEREF(__pyx_v_buf); - PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf)) __PYX_ERR(0, 189, __pyx_L1_error); __pyx_t_2 = 0; __pyx_r = __pyx_t_12; __pyx_t_12 = 0; @@ -4637,62 +7325,93 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_36read_nonblocking(struct __pyx */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_39read_timeout(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_38read_timeout[] = "Channel.read_timeout(self, int timeout, uint32_t size=1048576, bool is_stderr=False)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_39read_timeout(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_39read_timeout(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_38read_timeout, "Channel.read_timeout(self, int timeout, uint32_t size=0x100000, bool is_stderr=False)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_39read_timeout = {"read_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_39read_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_38read_timeout}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_39read_timeout(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 +) { int __pyx_v_timeout; uint32_t __pyx_v_size; int __pyx_v_is_stderr; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read_timeout (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,&__pyx_n_s_size,&__pyx_n_s_is_stderr,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,&__pyx_n_s_size,&__pyx_n_s_is_stderr,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 191, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 191, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_is_stderr); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_is_stderr); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 191, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_timeout") < 0)) __PYX_ERR(0, 191, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "read_timeout") < 0)) __PYX_ERR(0, 191, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -4717,10 +7436,18 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_39read_timeout(PyObject *__pyx_ __pyx_v_is_stderr = ((int)0); } } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("read_timeout", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 191, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("read_timeout", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 191, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.read_timeout", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -4736,6 +7463,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_39read_timeout(PyObject *__pyx_ */ /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4761,7 +7494,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_38read_timeout(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("read_timeout", 0); + __Pyx_RefNannySetupContext("read_timeout", 1); /* "ssh/channel.pyx":194 * c_ssh.uint32_t size=1024*1024, bint is_stderr=False): @@ -4783,6 +7516,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_38read_timeout(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4804,8 +7538,8 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_38read_timeout(struct __pyx_obj * with gil: * raise MemoryError */ - __pyx_t_1 = ((__pyx_v_cbuf == NULL) != 0); - if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_cbuf == NULL); + if (unlikely(__pyx_t_1)) { /* "ssh/channel.pyx":199 * cbuf = malloc(sizeof(char)*size) @@ -4908,7 +7642,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_38read_timeout(struct __pyx_obj * buf = cbuf[:rc] * finally: */ - __pyx_t_1 = ((__pyx_v_rc > 0) != 0); + __pyx_t_1 = (__pyx_v_rc > 0); if (__pyx_t_1) { /* "ssh/channel.pyx":205 @@ -4994,10 +7728,10 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_38read_timeout(struct __pyx_obj __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error); __Pyx_INCREF(__pyx_v_buf); __Pyx_GIVEREF(__pyx_v_buf); - PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf)) __PYX_ERR(0, 208, __pyx_L1_error); __pyx_t_2 = 0; __pyx_r = __pyx_t_12; __pyx_t_12 = 0; @@ -5033,59 +7767,100 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_38read_timeout(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_41request_env(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_40request_env[] = "Channel.request_env(self, name, value)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_41request_env(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_41request_env(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_40request_env, "Channel.request_env(self, name, value)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_41request_env = {"request_env", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_41request_env, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_40request_env}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_41request_env(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_name = 0; PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("request_env (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 210, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 210, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("request_env", 1, 2, 2, 1); __PYX_ERR(0, 210, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "request_env") < 0)) __PYX_ERR(0, 210, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "request_env") < 0)) __PYX_ERR(0, 210, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_name = values[0]; __pyx_v_value = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("request_env", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 210, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("request_env", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 210, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.request_env", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -5093,6 +7868,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_41request_env(PyObject *__pyx_v __pyx_r = __pyx_pf_3ssh_7channel_7Channel_40request_env(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_name, __pyx_v_value); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5111,7 +7892,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_40request_env(struct __pyx_obj_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_env", 0); + __Pyx_RefNannySetupContext("request_env", 1); /* "ssh/channel.pyx":211 * @@ -5175,6 +7956,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_40request_env(struct __pyx_obj_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -5254,15 +8036,98 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_40request_env(struct __pyx_obj_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_43request_exec(PyObject *__pyx_v_self, PyObject *__pyx_v_cmd); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_42request_exec[] = "Channel.request_exec(self, cmd)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_43request_exec(PyObject *__pyx_v_self, PyObject *__pyx_v_cmd) { - PyObject *__pyx_r = 0; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_43request_exec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_42request_exec, "Channel.request_exec(self, cmd)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_43request_exec = {"request_exec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_43request_exec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_42request_exec}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_43request_exec(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_cmd = 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("request_exec (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_42request_exec(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_cmd)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cmd,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cmd)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 220, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "request_exec") < 0)) __PYX_ERR(0, 220, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cmd = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("request_exec", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 220, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.channel.Channel.request_exec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_42request_exec(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_cmd); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5279,7 +8144,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_42request_exec(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_exec", 0); + __Pyx_RefNannySetupContext("request_exec", 1); /* "ssh/channel.pyx":221 * @@ -5317,6 +8182,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_42request_exec(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -5395,12 +8261,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_42request_exec(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_45request_pty(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_44request_pty[] = "Channel.request_pty(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_45request_pty(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_45request_pty(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_44request_pty, "Channel.request_pty(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_45request_pty = {"request_pty", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_45request_pty, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_44request_pty}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_45request_pty(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("request_pty (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("request_pty", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "request_pty", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_44request_pty(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -5417,7 +8311,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_44request_pty(struct __pyx_obj_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_pty", 0); + __Pyx_RefNannySetupContext("request_pty", 1); /* "ssh/channel.pyx":230 * def request_pty(self): @@ -5429,6 +8323,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_44request_pty(struct __pyx_obj_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -5506,59 +8401,100 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_44request_pty(struct __pyx_obj_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_47change_pty_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_46change_pty_size[] = "Channel.change_pty_size(self, int cols, int rows)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_47change_pty_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_47change_pty_size(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_46change_pty_size, "Channel.change_pty_size(self, int cols, int rows)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_47change_pty_size = {"change_pty_size", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_47change_pty_size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_46change_pty_size}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_47change_pty_size(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 +) { int __pyx_v_cols; int __pyx_v_rows; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("change_pty_size (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cols,&__pyx_n_s_rows,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cols,&__pyx_n_s_rows,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cols)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cols)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 234, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rows)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rows)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 234, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("change_pty_size", 1, 2, 2, 1); __PYX_ERR(0, 234, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "change_pty_size") < 0)) __PYX_ERR(0, 234, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "change_pty_size") < 0)) __PYX_ERR(0, 234, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_cols = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_cols == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 234, __pyx_L3_error) __pyx_v_rows = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_rows == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 234, __pyx_L3_error) } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("change_pty_size", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 234, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("change_pty_size", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 234, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.change_pty_size", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -5566,6 +8502,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_47change_pty_size(PyObject *__p __pyx_r = __pyx_pf_3ssh_7channel_7Channel_46change_pty_size(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_cols, __pyx_v_rows); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5579,7 +8521,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_46change_pty_size(struct __pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("change_pty_size", 0); + __Pyx_RefNannySetupContext("change_pty_size", 1); /* "ssh/channel.pyx":236 * def change_pty_size(self, int cols, int rows): @@ -5591,6 +8533,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_46change_pty_size(struct __pyx_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -5668,70 +8611,115 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_46change_pty_size(struct __pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_49request_pty_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_48request_pty_size[] = "Channel.request_pty_size(self, terminal, int col, int row)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_49request_pty_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_49request_pty_size(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_48request_pty_size, "Channel.request_pty_size(self, terminal, int col, int row)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_49request_pty_size = {"request_pty_size", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_49request_pty_size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_48request_pty_size}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_49request_pty_size(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_terminal = 0; int __pyx_v_col; int __pyx_v_row; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("request_pty_size (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_terminal,&__pyx_n_s_col,&__pyx_n_s_row,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_terminal,&__pyx_n_s_col,&__pyx_n_s_row,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_terminal)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_terminal)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_col)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_col)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("request_pty_size", 1, 3, 3, 1); __PYX_ERR(0, 240, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_row)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("request_pty_size", 1, 3, 3, 2); __PYX_ERR(0, 240, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "request_pty_size") < 0)) __PYX_ERR(0, 240, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "request_pty_size") < 0)) __PYX_ERR(0, 240, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); } __pyx_v_terminal = values[0]; __pyx_v_col = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_col == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L3_error) __pyx_v_row = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_row == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L3_error) } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("request_pty_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 240, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("request_pty_size", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 240, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.request_pty_size", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -5739,6 +8727,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_49request_pty_size(PyObject *__ __pyx_r = __pyx_pf_3ssh_7channel_7Channel_48request_pty_size(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_terminal, __pyx_v_col, __pyx_v_row); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5755,7 +8749,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_48request_pty_size(struct __pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_pty_size", 0); + __Pyx_RefNannySetupContext("request_pty_size", 1); /* "ssh/channel.pyx":241 * @@ -5793,6 +8787,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_48request_pty_size(struct __pyx { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -5871,15 +8866,98 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_48request_pty_size(struct __pyx */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_51request_send_signal(PyObject *__pyx_v_self, PyObject *__pyx_v_sig); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_50request_send_signal[] = "Channel.request_send_signal(self, sig)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_51request_send_signal(PyObject *__pyx_v_self, PyObject *__pyx_v_sig) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_51request_send_signal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_50request_send_signal, "Channel.request_send_signal(self, sig)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_51request_send_signal = {"request_send_signal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_51request_send_signal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_50request_send_signal}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_51request_send_signal(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_sig = 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("request_send_signal (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_50request_send_signal(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_sig)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sig,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sig)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 249, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "request_send_signal") < 0)) __PYX_ERR(0, 249, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_sig = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("request_send_signal", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 249, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.channel.Channel.request_send_signal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_50request_send_signal(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_sig); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5896,7 +8974,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_50request_send_signal(struct __ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_send_signal", 0); + __Pyx_RefNannySetupContext("request_send_signal", 1); /* "ssh/channel.pyx":250 * @@ -5934,6 +9012,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_50request_send_signal(struct __ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6012,28 +9091,98 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_50request_send_signal(struct __ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_53request_send_break(PyObject *__pyx_v_self, PyObject *__pyx_arg_length); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_52request_send_break[] = "Channel.request_send_break(self, uint32_t length)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_53request_send_break(PyObject *__pyx_v_self, PyObject *__pyx_arg_length) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_53request_send_break(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_52request_send_break, "Channel.request_send_break(self, uint32_t length)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_53request_send_break = {"request_send_break", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_53request_send_break, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_52request_send_break}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_53request_send_break(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 +) { uint32_t __pyx_v_length; + #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("request_send_break (wrapper)", 0); - assert(__pyx_arg_length); { - __pyx_v_length = __Pyx_PyInt_As_uint32_t(__pyx_arg_length); if (unlikely((__pyx_v_length == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 258, __pyx_L3_error) + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_length,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_length)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 258, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "request_send_break") < 0)) __PYX_ERR(0, 258, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_length = __Pyx_PyInt_As_uint32_t(values[0]); if (unlikely((__pyx_v_length == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 258, __pyx_L3_error) } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("request_send_break", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 258, __pyx_L3_error) + __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.request_send_break", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_52request_send_break(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((uint32_t)__pyx_v_length)); + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_52request_send_break(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_length); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6047,7 +9196,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_52request_send_break(struct __p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_send_break", 0); + __Pyx_RefNannySetupContext("request_send_break", 1); /* "ssh/channel.pyx":260 * def request_send_break(self, c_ssh.uint32_t length): @@ -6059,6 +9208,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_52request_send_break(struct __p { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6136,12 +9286,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_52request_send_break(struct __p */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_55request_shell(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_54request_shell[] = "Channel.request_shell(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_55request_shell(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_55request_shell(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_54request_shell, "Channel.request_shell(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_55request_shell = {"request_shell", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_55request_shell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_54request_shell}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_55request_shell(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("request_shell (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("request_shell", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "request_shell", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_54request_shell(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -6158,7 +9336,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_54request_shell(struct __pyx_ob int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_shell", 0); + __Pyx_RefNannySetupContext("request_shell", 1); /* "ssh/channel.pyx":267 * def request_shell(self): @@ -6170,6 +9348,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_54request_shell(struct __pyx_ob { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6247,12 +9426,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_54request_shell(struct __pyx_ob */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_57request_sftp(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_56request_sftp[] = "Channel.request_sftp(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_57request_sftp(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_57request_sftp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_56request_sftp, "Channel.request_sftp(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_57request_sftp = {"request_sftp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_57request_sftp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_56request_sftp}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_57request_sftp(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("request_sftp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("request_sftp", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "request_sftp", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_56request_sftp(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -6269,7 +9476,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_56request_sftp(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_sftp", 0); + __Pyx_RefNannySetupContext("request_sftp", 1); /* "ssh/channel.pyx":273 * def request_sftp(self): @@ -6281,6 +9488,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_56request_sftp(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6358,15 +9566,98 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_56request_sftp(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_59request_subsystem(PyObject *__pyx_v_self, PyObject *__pyx_v_subsystem); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_58request_subsystem[] = "Channel.request_subsystem(self, subsystem)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_59request_subsystem(PyObject *__pyx_v_self, PyObject *__pyx_v_subsystem) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_59request_subsystem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_58request_subsystem, "Channel.request_subsystem(self, subsystem)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_59request_subsystem = {"request_subsystem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_59request_subsystem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_58request_subsystem}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_59request_subsystem(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_subsystem = 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("request_subsystem (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_58request_subsystem(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_subsystem)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_subsystem,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_subsystem)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 277, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "request_subsystem") < 0)) __PYX_ERR(0, 277, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_subsystem = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("request_subsystem", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 277, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.channel.Channel.request_subsystem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_58request_subsystem(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_subsystem); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6383,7 +9674,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_58request_subsystem(struct __py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_subsystem", 0); + __Pyx_RefNannySetupContext("request_subsystem", 1); /* "ssh/channel.pyx":278 * @@ -6421,6 +9712,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_58request_subsystem(struct __py { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6499,51 +9791,81 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_58request_subsystem(struct __py */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_61request_x11(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_60request_x11[] = "Channel.request_x11(self, int screen_number, bool single_connection=True)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_61request_x11(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_61request_x11(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_60request_x11, "Channel.request_x11(self, int screen_number, bool single_connection=True)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_61request_x11 = {"request_x11", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_61request_x11, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_60request_x11}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_61request_x11(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 +) { int __pyx_v_screen_number; int __pyx_v_single_connection; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("request_x11 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_screen_number,&__pyx_n_s_single_connection,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_screen_number,&__pyx_n_s_single_connection,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_number)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_screen_number)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 286, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_single_connection); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_single_connection); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 286, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "request_x11") < 0)) __PYX_ERR(0, 286, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "request_x11") < 0)) __PYX_ERR(0, 286, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -6555,10 +9877,18 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_61request_x11(PyObject *__pyx_v __pyx_v_single_connection = ((int)1); } } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("request_x11", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 286, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("request_x11", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 286, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.request_x11", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -6566,6 +9896,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_61request_x11(PyObject *__pyx_v __pyx_r = __pyx_pf_3ssh_7channel_7Channel_60request_x11(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_screen_number, __pyx_v_single_connection); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6579,7 +9915,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_60request_x11(struct __pyx_obj_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("request_x11", 0); + __Pyx_RefNannySetupContext("request_x11", 1); /* "ssh/channel.pyx":288 * def request_x11(self, int screen_number, bint single_connection=True): @@ -6591,6 +9927,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_60request_x11(struct __pyx_obj_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6668,28 +10005,98 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_60request_x11(struct __pyx_obj_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_63set_blocking(PyObject *__pyx_v_self, PyObject *__pyx_arg_blocking); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_62set_blocking[] = "Channel.set_blocking(self, bool blocking)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_63set_blocking(PyObject *__pyx_v_self, PyObject *__pyx_arg_blocking) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_63set_blocking(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_62set_blocking, "Channel.set_blocking(self, bool blocking)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_63set_blocking = {"set_blocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_63set_blocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_62set_blocking}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_63set_blocking(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 +) { int __pyx_v_blocking; + #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("set_blocking (wrapper)", 0); - assert(__pyx_arg_blocking); { - __pyx_v_blocking = __Pyx_PyObject_IsTrue(__pyx_arg_blocking); if (unlikely((__pyx_v_blocking == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 293, __pyx_L3_error) + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_blocking,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_blocking)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 293, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_blocking") < 0)) __PYX_ERR(0, 293, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_blocking = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_blocking == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 293, __pyx_L3_error) } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_blocking", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 293, __pyx_L3_error) + __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.set_blocking", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_62set_blocking(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_blocking)); + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_62set_blocking(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_blocking); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6697,7 +10104,7 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_63set_blocking(PyObject *__pyx_ static PyObject *__pyx_pf_3ssh_7channel_7Channel_62set_blocking(struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self, int __pyx_v_blocking) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("set_blocking", 0); + __Pyx_RefNannySetupContext("set_blocking", 1); /* "ssh/channel.pyx":294 * @@ -6709,6 +10116,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_62set_blocking(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6767,15 +10175,98 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_62set_blocking(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_65set_counter(PyObject *__pyx_v_self, PyObject *__pyx_v_counter); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_64set_counter[] = "Channel.set_counter(self, counter)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_65set_counter(PyObject *__pyx_v_self, PyObject *__pyx_v_counter) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_65set_counter(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_64set_counter, "Channel.set_counter(self, counter)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_65set_counter = {"set_counter", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_65set_counter, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_64set_counter}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_65set_counter(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_counter = 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("set_counter (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_64set_counter(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_counter)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_counter,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_counter)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 297, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_counter") < 0)) __PYX_ERR(0, 297, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_counter = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_counter", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 297, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.channel.Channel.set_counter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_64set_counter(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_counter); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6786,7 +10277,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_64set_counter(CYTHON_UNUSED str int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_counter", 0); + __Pyx_RefNannySetupContext("set_counter", 1); /* "ssh/channel.pyx":298 * @@ -6824,25 +10315,105 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_64set_counter(CYTHON_UNUSED str */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_67write(PyObject *__pyx_v_self, PyObject *__pyx_v_data); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_66write[] = "Channel.write(self, data)\nWrite data to stdin on channel.\n\n :param data: Data to write.\n :type data: str or bytes\n :returns: Return code and bytes written tuples.\n :rtype: (int, int)\n "; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_67write(PyObject *__pyx_v_self, PyObject *__pyx_v_data) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_67write(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_66write, "Channel.write(self, data)\nWrite data to stdin on channel.\n\n :param data: Data to write.\n :type data: str or bytes\n :returns: Return code and bytes written tuples.\n :rtype: (int, int)\n "); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_67write = {"write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_67write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_66write}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_67write(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("write (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_data)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 300, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "write") < 0)) __PYX_ERR(0, 300, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_data = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("write", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 300, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.channel.Channel.write", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(((PyObject *)__pyx_v_data) == Py_None)) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "data"); __PYX_ERR(0, 300, __pyx_L1_error) } - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_66write(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_data)); + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_66write(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_data); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6867,7 +10438,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("write", 0); + __Pyx_RefNannySetupContext("write", 1); /* "ssh/channel.pyx":308 * :rtype: (int, int) @@ -6906,7 +10477,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 310, __pyx_L1_error) } - __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 310, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 310, __pyx_L1_error) __pyx_v_buf_remainder = __pyx_t_3; /* "ssh/channel.pyx":311 @@ -6937,6 +10508,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -6950,7 +10522,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 * self._channel, _buf, buf_remainder) */ while (1) { - __pyx_t_4 = ((__pyx_v_buf_remainder > 0) != 0); + __pyx_t_4 = (__pyx_v_buf_remainder > 0); if (!__pyx_t_4) break; /* "ssh/channel.pyx":316 @@ -6969,13 +10541,13 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 * with gil: * return handle_error_codes( */ - __pyx_t_5 = ((__pyx_v_rc < 0) != 0); + __pyx_t_5 = (__pyx_v_rc < 0); if (__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L9_bool_binop_done; } - __pyx_t_5 = ((__pyx_v_rc != SSH_AGAIN) != 0); + __pyx_t_5 = (__pyx_v_rc != SSH_AGAIN); __pyx_t_4 = __pyx_t_5; __pyx_L9_bool_binop_done:; if (__pyx_t_4) { @@ -7064,7 +10636,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 * break * _buf += rc */ - __pyx_t_4 = ((__pyx_v_rc == SSH_AGAIN) != 0); + __pyx_t_4 = (__pyx_v_rc == SSH_AGAIN); if (__pyx_t_4) { /* "ssh/channel.pyx":323 @@ -7163,9 +10735,9 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7)) __PYX_ERR(0, 327, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_r = __pyx_t_8; @@ -7203,25 +10775,105 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_66write(struct __pyx_obj_3ssh_7 */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_69write_stderr(PyObject *__pyx_v_self, PyObject *__pyx_v_data); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_68write_stderr[] = "Channel.write_stderr(self, data)\nWrite data to stderr.\n\n :param data: Data to write.\n :type data: str or bytes\n :returns: Return code and bytes written tuples.\n :rtype: (int, int)\n "; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_69write_stderr(PyObject *__pyx_v_self, PyObject *__pyx_v_data) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_69write_stderr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_68write_stderr, "Channel.write_stderr(self, data)\nWrite data to stderr.\n\n :param data: Data to write.\n :type data: str or bytes\n :returns: Return code and bytes written tuples.\n :rtype: (int, int)\n "); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_69write_stderr = {"write_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_69write_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_68write_stderr}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_69write_stderr(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("write_stderr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_data)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 329, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "write_stderr") < 0)) __PYX_ERR(0, 329, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_data = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("write_stderr", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 329, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.channel.Channel.write_stderr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(((PyObject *)__pyx_v_data) == Py_None)) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "data"); __PYX_ERR(0, 329, __pyx_L1_error) } - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_68write_stderr(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_data)); + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_68write_stderr(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v_data); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -7246,7 +10898,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("write_stderr", 0); + __Pyx_RefNannySetupContext("write_stderr", 1); /* "ssh/channel.pyx":337 * :rtype: (int, int) @@ -7285,7 +10937,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 339, __pyx_L1_error) } - __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 339, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 339, __pyx_L1_error) __pyx_v_buf_remainder = __pyx_t_3; /* "ssh/channel.pyx":340 @@ -7316,6 +10968,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -7329,7 +10982,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj * self._channel, _buf, buf_remainder) */ while (1) { - __pyx_t_4 = ((__pyx_v_buf_remainder > 0) != 0); + __pyx_t_4 = (__pyx_v_buf_remainder > 0); if (!__pyx_t_4) break; /* "ssh/channel.pyx":345 @@ -7348,13 +11001,13 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj * with gil: * return handle_error_codes( */ - __pyx_t_5 = ((__pyx_v_rc < 0) != 0); + __pyx_t_5 = (__pyx_v_rc < 0); if (__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L9_bool_binop_done; } - __pyx_t_5 = ((__pyx_v_rc != SSH_AGAIN) != 0); + __pyx_t_5 = (__pyx_v_rc != SSH_AGAIN); __pyx_t_4 = __pyx_t_5; __pyx_L9_bool_binop_done:; if (__pyx_t_4) { @@ -7443,7 +11096,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj * break * _buf += rc */ - __pyx_t_4 = ((__pyx_v_rc == SSH_AGAIN) != 0); + __pyx_t_4 = (__pyx_v_rc == SSH_AGAIN); if (__pyx_t_4) { /* "ssh/channel.pyx":352 @@ -7542,9 +11195,9 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 356, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 356, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7)) __PYX_ERR(0, 356, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_r = __pyx_t_8; @@ -7582,12 +11235,40 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_68write_stderr(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_71window_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_70window_size[] = "Channel.window_size(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_71window_size(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_71window_size(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_70window_size, "Channel.window_size(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_71window_size = {"window_size", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_71window_size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_70window_size}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_71window_size(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("window_size (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("window_size", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "window_size", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_70window_size(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -7603,7 +11284,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_70window_size(struct __pyx_obj_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("window_size", 0); + __Pyx_RefNannySetupContext("window_size", 1); /* "ssh/channel.pyx":360 * def window_size(self): @@ -7615,6 +11296,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_70window_size(struct __pyx_obj_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -7691,23 +11373,48 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_70window_size(struct __pyx_obj_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_73select(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_72select[] = "Channel.select(self, channels, outchannels, maxfd, readfds, timeout=None)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_73select(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_73select(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_72select, "Channel.select(self, channels, outchannels, maxfd, readfds, timeout=None)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_73select = {"select", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_73select, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_72select}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_73select(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_channels = 0; CYTHON_UNUSED PyObject *__pyx_v_outchannels = 0; CYTHON_UNUSED PyObject *__pyx_v_maxfd = 0; CYTHON_UNUSED PyObject *__pyx_v_readfds = 0; CYTHON_UNUSED PyObject *__pyx_v_timeout = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("select (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_channels,&__pyx_n_s_outchannels,&__pyx_n_s_maxfd,&__pyx_n_s_readfds,&__pyx_n_s_timeout,0}; - PyObject* values[5] = {0,0,0,0,0}; + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_channels,&__pyx_n_s_outchannels,&__pyx_n_s_maxfd,&__pyx_n_s_readfds,&__pyx_n_s_timeout,0}; /* "ssh/channel.pyx":365 * @@ -7715,65 +11422,82 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_73select(PyObject *__pyx_v_self * readfds, timeout=None): # <<<<<<<<<<<<<< * raise NotImplementedError */ - values[4] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_channels)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_channels)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_outchannels)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_outchannels)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("select", 0, 4, 5, 1); __PYX_ERR(0, 364, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_maxfd)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxfd)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("select", 0, 4, 5, 2); __PYX_ERR(0, 364, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_readfds)) != 0)) kw_args--; + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_readfds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("select", 0, 4, 5, 3); __PYX_ERR(0, 364, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout); - if (value) { values[4] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "select") < 0)) __PYX_ERR(0, 364, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "select") < 0)) __PYX_ERR(0, 364, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -7784,10 +11508,18 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_73select(PyObject *__pyx_v_self __pyx_v_readfds = values[3]; __pyx_v_timeout = values[4]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("select", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 364, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("select", 0, 4, 5, __pyx_nargs); __PYX_ERR(0, 364, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.channel.Channel.select", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -7813,6 +11545,12 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_73select(PyObject *__pyx_v_self __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -7823,7 +11561,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_72select(CYTHON_UNUSED struct _ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("select", 0); + __Pyx_RefNannySetupContext("select", 1); /* "ssh/channel.pyx":366 * def select(self, channels not None, outchannels not None, maxfd, @@ -7861,9 +11599,11 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_72select(CYTHON_UNUSED struct _ /* Python wrapper */ static PyObject *__pyx_pw_3ssh_7channel_7Channel_6closed_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_7channel_7Channel_6closed_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_3ssh_7channel_7Channel_6closed___get__(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -7878,7 +11618,7 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_6closed___get__(struct __pyx_ob int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->closed); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -7899,17 +11639,45 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_6closed___get__(struct __pyx_ob /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_74__reduce_cython__[] = "Channel.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_74__reduce_cython__, "Channel.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_75__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_74__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7channel_7Channel_74__reduce_cython__(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self)); /* function exit code */ @@ -7920,33 +11688,28 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__(PyObject *_ static PyObject *__pyx_pf_3ssh_7channel_7Channel_74__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_7channel_Channel *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.channel.Channel.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -7956,21 +11719,104 @@ static PyObject *__pyx_pf_3ssh_7channel_7Channel_74__reduce_cython__(CYTHON_UNUS /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_7channel_7Channel_76__setstate_cython__[] = "Channel.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7channel_7Channel_76__setstate_cython__, "Channel.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_7channel_7Channel_77__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_76__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_7channel_7Channel_76__setstate_cython__(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.channel.Channel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_7channel_7Channel_76__setstate_cython__(((struct __pyx_obj_3ssh_7channel_Channel *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -7978,33 +11824,28 @@ static PyObject *__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__(PyObject static PyObject *__pyx_pf_3ssh_7channel_7Channel_76__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.channel.Channel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -8016,12 +11857,17 @@ static struct __pyx_vtabstruct_3ssh_7channel_Channel __pyx_vtable_3ssh_7channel_ static PyObject *__pyx_tp_new_3ssh_7channel_Channel(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_3ssh_7channel_Channel *p; PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif p = ((struct __pyx_obj_3ssh_7channel_Channel *)o); p->__pyx_vtab = __pyx_vtabptr_3ssh_7channel_Channel; p->_session = ((struct __pyx_obj_3ssh_7session_Session *)Py_None); Py_INCREF(Py_None); @@ -8035,8 +11881,10 @@ static PyObject *__pyx_tp_new_3ssh_7channel_Channel(PyTypeObject *t, PyObject *a static void __pyx_tp_dealloc_3ssh_7channel_Channel(PyObject *o) { struct __pyx_obj_3ssh_7channel_Channel *p = (struct __pyx_obj_3ssh_7channel_Channel *)o; #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { - if (PyObject_CallFinalizerFromDealloc(o)) return; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_3ssh_7channel_Channel) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif PyObject_GC_UnTrack(o); @@ -8049,7 +11897,14 @@ static void __pyx_tp_dealloc_3ssh_7channel_Channel(PyObject *o) { PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->_session); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static int __pyx_tp_traverse_3ssh_7channel_Channel(PyObject *o, visitproc v, void *a) { @@ -8079,55 +11934,73 @@ static PyObject *__pyx_getprop_3ssh_7channel_7Channel_closed(PyObject *o, CYTHON } static PyMethodDef __pyx_methods_3ssh_7channel_Channel[] = { - {"close", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_5close, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_4close}, - {"get_exit_status", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_7get_exit_status, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_6get_exit_status}, - {"get_session", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_9get_session, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_8get_session}, - {"is_closed", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_11is_closed, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_10is_closed}, - {"is_eof", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_13is_eof, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_12is_eof}, - {"is_open", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_15is_open, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_14is_open}, - {"send_eof", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_17send_eof, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_16send_eof}, - {"request_auth_agent", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_19request_auth_agent, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_18request_auth_agent}, - {"open_auth_agent", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_21open_auth_agent, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_20open_auth_agent}, - {"open_forward", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_23open_forward, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_22open_forward}, - {"open_session", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_25open_session, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_24open_session}, - {"open_x11", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_27open_x11, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_26open_x11}, - {"accept_x11", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_29accept_x11, METH_O, __pyx_doc_3ssh_7channel_7Channel_28accept_x11}, - {"poll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_31poll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_30poll}, - {"poll_timeout", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_33poll_timeout, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_32poll_timeout}, - {"read", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_35read, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_34read}, - {"read_nonblocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_36read_nonblocking}, - {"read_timeout", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_39read_timeout, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_38read_timeout}, - {"request_env", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_41request_env, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_40request_env}, - {"request_exec", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_43request_exec, METH_O, __pyx_doc_3ssh_7channel_7Channel_42request_exec}, - {"request_pty", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_45request_pty, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_44request_pty}, - {"change_pty_size", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_47change_pty_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_46change_pty_size}, - {"request_pty_size", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_49request_pty_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_48request_pty_size}, - {"request_send_signal", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_51request_send_signal, METH_O, __pyx_doc_3ssh_7channel_7Channel_50request_send_signal}, - {"request_send_break", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_53request_send_break, METH_O, __pyx_doc_3ssh_7channel_7Channel_52request_send_break}, - {"request_shell", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_55request_shell, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_54request_shell}, - {"request_sftp", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_57request_sftp, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_56request_sftp}, - {"request_subsystem", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_59request_subsystem, METH_O, __pyx_doc_3ssh_7channel_7Channel_58request_subsystem}, - {"request_x11", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_61request_x11, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_60request_x11}, - {"set_blocking", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_63set_blocking, METH_O, __pyx_doc_3ssh_7channel_7Channel_62set_blocking}, - {"set_counter", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_65set_counter, METH_O, __pyx_doc_3ssh_7channel_7Channel_64set_counter}, - {"write", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_67write, METH_O, __pyx_doc_3ssh_7channel_7Channel_66write}, - {"write_stderr", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_69write_stderr, METH_O, __pyx_doc_3ssh_7channel_7Channel_68write_stderr}, - {"window_size", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_71window_size, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_70window_size}, - {"select", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7channel_7Channel_73select, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_72select}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_7channel_7Channel_74__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__, METH_O, __pyx_doc_3ssh_7channel_7Channel_76__setstate_cython__}, + {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_5close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_4close}, + {"get_exit_status", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_7get_exit_status, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_6get_exit_status}, + {"get_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_9get_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_8get_session}, + {"is_closed", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_11is_closed, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_10is_closed}, + {"is_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_13is_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_12is_eof}, + {"is_open", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_15is_open, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_14is_open}, + {"send_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_17send_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_16send_eof}, + {"request_auth_agent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_19request_auth_agent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_18request_auth_agent}, + {"open_auth_agent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_21open_auth_agent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_20open_auth_agent}, + {"open_forward", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_23open_forward, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_22open_forward}, + {"open_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_25open_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_24open_session}, + {"open_x11", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_27open_x11, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_26open_x11}, + {"accept_x11", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_29accept_x11, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_28accept_x11}, + {"poll", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_31poll, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_30poll}, + {"poll_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_33poll_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_32poll_timeout}, + {"read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_35read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_34read}, + {"read_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_37read_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_36read_nonblocking}, + {"read_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_39read_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_38read_timeout}, + {"request_env", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_41request_env, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_40request_env}, + {"request_exec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_43request_exec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_42request_exec}, + {"request_pty", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_45request_pty, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_44request_pty}, + {"change_pty_size", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_47change_pty_size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_46change_pty_size}, + {"request_pty_size", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_49request_pty_size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_48request_pty_size}, + {"request_send_signal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_51request_send_signal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_50request_send_signal}, + {"request_send_break", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_53request_send_break, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_52request_send_break}, + {"request_shell", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_55request_shell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_54request_shell}, + {"request_sftp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_57request_sftp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_56request_sftp}, + {"request_subsystem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_59request_subsystem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_58request_subsystem}, + {"request_x11", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_61request_x11, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_60request_x11}, + {"set_blocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_63set_blocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_62set_blocking}, + {"set_counter", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_65set_counter, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_64set_counter}, + {"write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_67write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_66write}, + {"write_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_69write_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_68write_stderr}, + {"window_size", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_71window_size, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_70window_size}, + {"select", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_73select, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_72select}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_75__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_74__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7channel_7Channel_77__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7channel_7Channel_76__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_3ssh_7channel_Channel[] = { - {(char *)"session", __pyx_getprop_3ssh_7channel_7Channel_session, 0, (char *)"Originating session.", 0}, + {(char *)"session", __pyx_getprop_3ssh_7channel_7Channel_session, 0, (char *)PyDoc_STR("Originating session."), 0}, {(char *)"closed", __pyx_getprop_3ssh_7channel_7Channel_closed, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_7channel_Channel_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_3ssh_7channel_Channel}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_3ssh_7channel_Channel}, + {Py_tp_clear, (void *)__pyx_tp_clear_3ssh_7channel_Channel}, + {Py_tp_methods, (void *)__pyx_methods_3ssh_7channel_Channel}, + {Py_tp_getset, (void *)__pyx_getsets_3ssh_7channel_Channel}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_7channel_Channel}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_7channel_Channel_spec = { + "ssh.channel.Channel", + sizeof(struct __pyx_obj_3ssh_7channel_Channel), + 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_3ssh_7channel_Channel_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_7channel_Channel = { PyVarObject_HEAD_INIT(0, 0) - "ssh.channel.Channel", /*tp_name*/ + "ssh.channel.""Channel", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_7channel_Channel), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_7channel_Channel, /*tp_dealloc*/ @@ -8170,7 +12043,9 @@ static PyTypeObject __pyx_type_3ssh_7channel_Channel = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_7channel_Channel, /*tp_new*/ @@ -8184,54 +12059,30 @@ static PyTypeObject __pyx_type_3ssh_7channel_Channel = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_channel(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_channel}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "channel", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -8241,48 +12092,171 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_b_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 0, 0}, - {&__pyx_n_s_Channel, __pyx_k_Channel, sizeof(__pyx_k_Channel), 0, 0, 1, 1}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_channels, __pyx_k_channels, sizeof(__pyx_k_channels), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_col, __pyx_k_col, sizeof(__pyx_k_col), 0, 0, 1, 1}, - {&__pyx_n_s_cols, __pyx_k_cols, sizeof(__pyx_k_cols), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_is_stderr, __pyx_k_is_stderr, sizeof(__pyx_k_is_stderr), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_maxfd, __pyx_k_maxfd, sizeof(__pyx_k_maxfd), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_outchannels, __pyx_k_outchannels, sizeof(__pyx_k_outchannels), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_readfds, __pyx_k_readfds, sizeof(__pyx_k_readfds), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_remotehost, __pyx_k_remotehost, sizeof(__pyx_k_remotehost), 0, 0, 1, 1}, - {&__pyx_n_s_remoteport, __pyx_k_remoteport, sizeof(__pyx_k_remoteport), 0, 0, 1, 1}, - {&__pyx_n_s_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 0, 1, 1}, - {&__pyx_n_s_rows, __pyx_k_rows, sizeof(__pyx_k_rows), 0, 0, 1, 1}, - {&__pyx_n_s_screen_number, __pyx_k_screen_number, sizeof(__pyx_k_screen_number), 0, 0, 1, 1}, - {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_single_connection, __pyx_k_single_connection, sizeof(__pyx_k_single_connection), 0, 0, 1, 1}, - {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, - {&__pyx_n_s_sourcehost, __pyx_k_sourcehost, sizeof(__pyx_k_sourcehost), 0, 0, 1, 1}, - {&__pyx_n_s_sourceport, __pyx_k_sourceport, sizeof(__pyx_k_sourceport), 0, 0, 1, 1}, - {&__pyx_n_s_terminal, __pyx_k_terminal, sizeof(__pyx_k_terminal), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, - {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_b_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 0, 0}, + {&__pyx_n_s_Channel, __pyx_k_Channel, sizeof(__pyx_k_Channel), 0, 0, 1, 1}, + {&__pyx_n_s_Channel___reduce_cython, __pyx_k_Channel___reduce_cython, sizeof(__pyx_k_Channel___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Channel___setstate_cython, __pyx_k_Channel___setstate_cython, sizeof(__pyx_k_Channel___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_accept_x11, __pyx_k_Channel_accept_x11, sizeof(__pyx_k_Channel_accept_x11), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_change_pty_size, __pyx_k_Channel_change_pty_size, sizeof(__pyx_k_Channel_change_pty_size), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_close, __pyx_k_Channel_close, sizeof(__pyx_k_Channel_close), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_get_exit_status, __pyx_k_Channel_get_exit_status, sizeof(__pyx_k_Channel_get_exit_status), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_get_session, __pyx_k_Channel_get_session, sizeof(__pyx_k_Channel_get_session), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_is_closed, __pyx_k_Channel_is_closed, sizeof(__pyx_k_Channel_is_closed), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_is_eof, __pyx_k_Channel_is_eof, sizeof(__pyx_k_Channel_is_eof), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_is_open, __pyx_k_Channel_is_open, sizeof(__pyx_k_Channel_is_open), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_open_auth_agent, __pyx_k_Channel_open_auth_agent, sizeof(__pyx_k_Channel_open_auth_agent), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_open_forward, __pyx_k_Channel_open_forward, sizeof(__pyx_k_Channel_open_forward), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_open_session, __pyx_k_Channel_open_session, sizeof(__pyx_k_Channel_open_session), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_open_x11, __pyx_k_Channel_open_x11, sizeof(__pyx_k_Channel_open_x11), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_poll, __pyx_k_Channel_poll, sizeof(__pyx_k_Channel_poll), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_poll_timeout, __pyx_k_Channel_poll_timeout, sizeof(__pyx_k_Channel_poll_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_read, __pyx_k_Channel_read, sizeof(__pyx_k_Channel_read), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_read_nonblocking, __pyx_k_Channel_read_nonblocking, sizeof(__pyx_k_Channel_read_nonblocking), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_read_timeout, __pyx_k_Channel_read_timeout, sizeof(__pyx_k_Channel_read_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_auth_agent, __pyx_k_Channel_request_auth_agent, sizeof(__pyx_k_Channel_request_auth_agent), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_env, __pyx_k_Channel_request_env, sizeof(__pyx_k_Channel_request_env), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_exec, __pyx_k_Channel_request_exec, sizeof(__pyx_k_Channel_request_exec), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_pty, __pyx_k_Channel_request_pty, sizeof(__pyx_k_Channel_request_pty), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_pty_size, __pyx_k_Channel_request_pty_size, sizeof(__pyx_k_Channel_request_pty_size), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_send_break, __pyx_k_Channel_request_send_break, sizeof(__pyx_k_Channel_request_send_break), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_send_signal, __pyx_k_Channel_request_send_signal, sizeof(__pyx_k_Channel_request_send_signal), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_sftp, __pyx_k_Channel_request_sftp, sizeof(__pyx_k_Channel_request_sftp), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_shell, __pyx_k_Channel_request_shell, sizeof(__pyx_k_Channel_request_shell), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_subsystem, __pyx_k_Channel_request_subsystem, sizeof(__pyx_k_Channel_request_subsystem), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_request_x11, __pyx_k_Channel_request_x11, sizeof(__pyx_k_Channel_request_x11), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_select, __pyx_k_Channel_select, sizeof(__pyx_k_Channel_select), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_send_eof, __pyx_k_Channel_send_eof, sizeof(__pyx_k_Channel_send_eof), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_set_blocking, __pyx_k_Channel_set_blocking, sizeof(__pyx_k_Channel_set_blocking), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_set_counter, __pyx_k_Channel_set_counter, sizeof(__pyx_k_Channel_set_counter), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_window_size, __pyx_k_Channel_window_size, sizeof(__pyx_k_Channel_window_size), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_write, __pyx_k_Channel_write, sizeof(__pyx_k_Channel_write), 0, 0, 1, 1}, + {&__pyx_n_s_Channel_write_stderr, __pyx_k_Channel_write_stderr, sizeof(__pyx_k_Channel_write_stderr), 0, 0, 1, 1}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s__66, __pyx_k__66, sizeof(__pyx_k__66), 0, 0, 1, 1}, + {&__pyx_n_s_accept_x11, __pyx_k_accept_x11, sizeof(__pyx_k_accept_x11), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_b_buf, __pyx_k_b_buf, sizeof(__pyx_k_b_buf), 0, 0, 1, 1}, + {&__pyx_n_s_b_cmd, __pyx_k_b_cmd, sizeof(__pyx_k_b_cmd), 0, 0, 1, 1}, + {&__pyx_n_s_b_name, __pyx_k_b_name, sizeof(__pyx_k_b_name), 0, 0, 1, 1}, + {&__pyx_n_s_b_remotehost, __pyx_k_b_remotehost, sizeof(__pyx_k_b_remotehost), 0, 0, 1, 1}, + {&__pyx_n_s_b_sig, __pyx_k_b_sig, sizeof(__pyx_k_b_sig), 0, 0, 1, 1}, + {&__pyx_n_s_b_sourcehost, __pyx_k_b_sourcehost, sizeof(__pyx_k_b_sourcehost), 0, 0, 1, 1}, + {&__pyx_n_s_b_sys, __pyx_k_b_sys, sizeof(__pyx_k_b_sys), 0, 0, 1, 1}, + {&__pyx_n_s_b_terminal, __pyx_k_b_terminal, sizeof(__pyx_k_b_terminal), 0, 0, 1, 1}, + {&__pyx_n_s_b_value, __pyx_k_b_value, sizeof(__pyx_k_b_value), 0, 0, 1, 1}, + {&__pyx_n_s_blocking, __pyx_k_blocking, sizeof(__pyx_k_blocking), 0, 0, 1, 1}, + {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1}, + {&__pyx_n_s_buf_2, __pyx_k_buf_2, sizeof(__pyx_k_buf_2), 0, 0, 1, 1}, + {&__pyx_n_s_buf_remainder, __pyx_k_buf_remainder, sizeof(__pyx_k_buf_remainder), 0, 0, 1, 1}, + {&__pyx_n_s_buf_tot_size, __pyx_k_buf_tot_size, sizeof(__pyx_k_buf_tot_size), 0, 0, 1, 1}, + {&__pyx_n_s_bytes_written, __pyx_k_bytes_written, sizeof(__pyx_k_bytes_written), 0, 0, 1, 1}, + {&__pyx_n_s_c_cmd, __pyx_k_c_cmd, sizeof(__pyx_k_c_cmd), 0, 0, 1, 1}, + {&__pyx_n_s_c_name, __pyx_k_c_name, sizeof(__pyx_k_c_name), 0, 0, 1, 1}, + {&__pyx_n_s_c_remotehost, __pyx_k_c_remotehost, sizeof(__pyx_k_c_remotehost), 0, 0, 1, 1}, + {&__pyx_n_s_c_sig, __pyx_k_c_sig, sizeof(__pyx_k_c_sig), 0, 0, 1, 1}, + {&__pyx_n_s_c_sourcehost, __pyx_k_c_sourcehost, sizeof(__pyx_k_c_sourcehost), 0, 0, 1, 1}, + {&__pyx_n_s_c_sys, __pyx_k_c_sys, sizeof(__pyx_k_c_sys), 0, 0, 1, 1}, + {&__pyx_n_s_c_terminal, __pyx_k_c_terminal, sizeof(__pyx_k_c_terminal), 0, 0, 1, 1}, + {&__pyx_n_s_c_value, __pyx_k_c_value, sizeof(__pyx_k_c_value), 0, 0, 1, 1}, + {&__pyx_n_s_cbuf, __pyx_k_cbuf, sizeof(__pyx_k_cbuf), 0, 0, 1, 1}, + {&__pyx_n_s_chan, __pyx_k_chan, sizeof(__pyx_k_chan), 0, 0, 1, 1}, + {&__pyx_n_s_chan_2, __pyx_k_chan_2, sizeof(__pyx_k_chan_2), 0, 0, 1, 1}, + {&__pyx_n_s_change_pty_size, __pyx_k_change_pty_size, sizeof(__pyx_k_change_pty_size), 0, 0, 1, 1}, + {&__pyx_n_s_channels, __pyx_k_channels, sizeof(__pyx_k_channels), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_cmd, __pyx_k_cmd, sizeof(__pyx_k_cmd), 0, 0, 1, 1}, + {&__pyx_n_s_col, __pyx_k_col, sizeof(__pyx_k_col), 0, 0, 1, 1}, + {&__pyx_n_s_cols, __pyx_k_cols, sizeof(__pyx_k_cols), 0, 0, 1, 1}, + {&__pyx_n_s_counter, __pyx_k_counter, sizeof(__pyx_k_counter), 0, 0, 1, 1}, + {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_get_exit_status, __pyx_k_get_exit_status, sizeof(__pyx_k_get_exit_status), 0, 0, 1, 1}, + {&__pyx_n_s_get_session, __pyx_k_get_session, sizeof(__pyx_k_get_session), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_is_closed, __pyx_k_is_closed, sizeof(__pyx_k_is_closed), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_n_s_is_eof, __pyx_k_is_eof, sizeof(__pyx_k_is_eof), 0, 0, 1, 1}, + {&__pyx_n_s_is_open, __pyx_k_is_open, sizeof(__pyx_k_is_open), 0, 0, 1, 1}, + {&__pyx_n_s_is_stderr, __pyx_k_is_stderr, sizeof(__pyx_k_is_stderr), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_length, __pyx_k_length, sizeof(__pyx_k_length), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_maxfd, __pyx_k_maxfd, sizeof(__pyx_k_maxfd), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_open_auth_agent, __pyx_k_open_auth_agent, sizeof(__pyx_k_open_auth_agent), 0, 0, 1, 1}, + {&__pyx_n_s_open_forward, __pyx_k_open_forward, sizeof(__pyx_k_open_forward), 0, 0, 1, 1}, + {&__pyx_n_s_open_session, __pyx_k_open_session, sizeof(__pyx_k_open_session), 0, 0, 1, 1}, + {&__pyx_n_s_open_x11, __pyx_k_open_x11, sizeof(__pyx_k_open_x11), 0, 0, 1, 1}, + {&__pyx_n_s_outchannels, __pyx_k_outchannels, sizeof(__pyx_k_outchannels), 0, 0, 1, 1}, + {&__pyx_n_s_poll, __pyx_k_poll, sizeof(__pyx_k_poll), 0, 0, 1, 1}, + {&__pyx_n_s_poll_timeout, __pyx_k_poll_timeout, sizeof(__pyx_k_poll_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1}, + {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1}, + {&__pyx_n_s_read_nonblocking, __pyx_k_read_nonblocking, sizeof(__pyx_k_read_nonblocking), 0, 0, 1, 1}, + {&__pyx_n_s_read_timeout, __pyx_k_read_timeout, sizeof(__pyx_k_read_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_readfds, __pyx_k_readfds, sizeof(__pyx_k_readfds), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_remotehost, __pyx_k_remotehost, sizeof(__pyx_k_remotehost), 0, 0, 1, 1}, + {&__pyx_n_s_remoteport, __pyx_k_remoteport, sizeof(__pyx_k_remoteport), 0, 0, 1, 1}, + {&__pyx_n_s_request_auth_agent, __pyx_k_request_auth_agent, sizeof(__pyx_k_request_auth_agent), 0, 0, 1, 1}, + {&__pyx_n_s_request_env, __pyx_k_request_env, sizeof(__pyx_k_request_env), 0, 0, 1, 1}, + {&__pyx_n_s_request_exec, __pyx_k_request_exec, sizeof(__pyx_k_request_exec), 0, 0, 1, 1}, + {&__pyx_n_s_request_pty, __pyx_k_request_pty, sizeof(__pyx_k_request_pty), 0, 0, 1, 1}, + {&__pyx_n_s_request_pty_size, __pyx_k_request_pty_size, sizeof(__pyx_k_request_pty_size), 0, 0, 1, 1}, + {&__pyx_n_s_request_send_break, __pyx_k_request_send_break, sizeof(__pyx_k_request_send_break), 0, 0, 1, 1}, + {&__pyx_n_s_request_send_signal, __pyx_k_request_send_signal, sizeof(__pyx_k_request_send_signal), 0, 0, 1, 1}, + {&__pyx_n_s_request_sftp, __pyx_k_request_sftp, sizeof(__pyx_k_request_sftp), 0, 0, 1, 1}, + {&__pyx_n_s_request_shell, __pyx_k_request_shell, sizeof(__pyx_k_request_shell), 0, 0, 1, 1}, + {&__pyx_n_s_request_subsystem, __pyx_k_request_subsystem, sizeof(__pyx_k_request_subsystem), 0, 0, 1, 1}, + {&__pyx_n_s_request_x11, __pyx_k_request_x11, sizeof(__pyx_k_request_x11), 0, 0, 1, 1}, + {&__pyx_n_s_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 0, 1, 1}, + {&__pyx_n_s_rows, __pyx_k_rows, sizeof(__pyx_k_rows), 0, 0, 1, 1}, + {&__pyx_n_s_screen_number, __pyx_k_screen_number, sizeof(__pyx_k_screen_number), 0, 0, 1, 1}, + {&__pyx_n_s_select, __pyx_k_select, sizeof(__pyx_k_select), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_send_eof, __pyx_k_send_eof, sizeof(__pyx_k_send_eof), 0, 0, 1, 1}, + {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1}, + {&__pyx_n_s_set_blocking, __pyx_k_set_blocking, sizeof(__pyx_k_set_blocking), 0, 0, 1, 1}, + {&__pyx_n_s_set_counter, __pyx_k_set_counter, sizeof(__pyx_k_set_counter), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_sig, __pyx_k_sig, sizeof(__pyx_k_sig), 0, 0, 1, 1}, + {&__pyx_n_s_single_connection, __pyx_k_single_connection, sizeof(__pyx_k_single_connection), 0, 0, 1, 1}, + {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, + {&__pyx_n_s_sourcehost, __pyx_k_sourcehost, sizeof(__pyx_k_sourcehost), 0, 0, 1, 1}, + {&__pyx_n_s_sourceport, __pyx_k_sourceport, sizeof(__pyx_k_sourceport), 0, 0, 1, 1}, + {&__pyx_n_s_ssh_channel, __pyx_k_ssh_channel, sizeof(__pyx_k_ssh_channel), 0, 0, 1, 1}, + {&__pyx_kp_s_ssh_channel_pyx, __pyx_k_ssh_channel_pyx, sizeof(__pyx_k_ssh_channel_pyx), 0, 0, 1, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_subsystem, __pyx_k_subsystem, sizeof(__pyx_k_subsystem), 0, 0, 1, 1}, + {&__pyx_n_s_terminal, __pyx_k_terminal, sizeof(__pyx_k_terminal), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, + {&__pyx_n_s_timeout_ms, __pyx_k_timeout_ms, sizeof(__pyx_k_timeout_ms), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_s_window_size, __pyx_k_window_size, sizeof(__pyx_k_window_size), 0, 0, 1, 1}, + {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, + {&__pyx_n_s_write_stderr, __pyx_k_write_stderr, sizeof(__pyx_k_write_stderr), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 138, __pyx_L1_error) __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 298, __pyx_L1_error) @@ -8291,1244 +12265,4612 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_L1_error:; return -1; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "ssh/channel.pyx":49 + * return chan + * + * def close(self): # <<<<<<<<<<<<<< + * cdef int rc + * if self.closed: */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_close, 49, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 49, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} + /* "ssh/channel.pyx":59 + * return handle_error_codes(rc, self._session._session) + * + * def get_exit_status(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_get_exit_status, 59, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 59, __pyx_L1_error) -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} + /* "ssh/channel.pyx":65 + * return rc + * + * def get_session(self): # <<<<<<<<<<<<<< + * return self.session + * + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_get_session, 65, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 65, __pyx_L1_error) -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + /* "ssh/channel.pyx":68 + * return self.session + * + * def is_closed(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_is_closed, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 68, __pyx_L1_error) -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "ssh/channel.pyx":74 + * return rc != 0 + * + * def is_eof(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_is_eof, 74, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 74, __pyx_L1_error) -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "ssh/channel.pyx":80 + * return bool(rc) + * + * def is_open(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_is_open, 80, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 80, __pyx_L1_error) -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "ssh/channel.pyx":86 + * return bool(rc) + * + * def send_eof(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_send_eof, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 86, __pyx_L1_error) -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __pyx_vtabptr_3ssh_7channel_Channel = &__pyx_vtable_3ssh_7channel_Channel; - __pyx_vtable_3ssh_7channel_Channel.from_ptr = (struct __pyx_obj_3ssh_7channel_Channel *(*)(ssh_channel, struct __pyx_obj_3ssh_7session_Session *))__pyx_f_3ssh_7channel_7Channel_from_ptr; - if (PyType_Ready(&__pyx_type_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_7channel_Channel.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_7channel_Channel.tp_dictoffset && __pyx_type_3ssh_7channel_Channel.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_7channel_Channel.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (__Pyx_SetVtable(__pyx_type_3ssh_7channel_Channel.tp_dict, __pyx_vtabptr_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Channel, (PyObject *)&__pyx_type_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - __pyx_ptype_3ssh_7channel_Channel = &__pyx_type_3ssh_7channel_Channel; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} + /* "ssh/channel.pyx":92 + * return handle_error_codes(rc, self._session._session) + * + * def request_auth_agent(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_auth_agent, 92, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 92, __pyx_L1_error) -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule("ssh.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(3, 19, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} + /* "ssh/channel.pyx":98 + * return handle_error_codes(rc, self._session._session) + * + * def open_auth_agent(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_open_auth_agent, 98, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 98, __pyx_L1_error) -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "ssh/channel.pyx":104 + * return handle_error_codes(rc, self._session._session) + * + * def open_forward(self, remotehost, int remoteport, # <<<<<<<<<<<<<< + * sourcehost, int sourceport): + * cdef bytes b_remotehost = to_bytes(remotehost) + */ + __pyx_tuple__13 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_remotehost, __pyx_n_s_remoteport, __pyx_n_s_sourcehost, __pyx_n_s_sourceport, __pyx_n_s_b_remotehost, __pyx_n_s_c_remotehost, __pyx_n_s_b_sourcehost, __pyx_n_s_c_sourcehost, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_open_forward, 104, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 104, __pyx_L1_error) -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_3ssh_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_3ssh_5utils_to_str, "PyObject *(char const *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} + /* "ssh/channel.pyx":117 + * return handle_error_codes(rc, self._session._session) + * + * def open_session(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_open_session, 117, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 117, __pyx_L1_error) + /* "ssh/channel.pyx":123 + * return handle_error_codes(rc, self._session._session) + * + * def open_x11(self, sourcehost, int sourceport): # <<<<<<<<<<<<<< + * cdef bytes b_sourcehost = to_bytes(sourcehost) + * cdef const_char *c_sourcehost = b_sourcehost + */ + __pyx_tuple__16 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_sourcehost, __pyx_n_s_sourceport, __pyx_n_s_b_sourcehost, __pyx_n_s_c_sourcehost, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_open_x11, 123, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 123, __pyx_L1_error) -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void + /* "ssh/channel.pyx":132 + * return handle_error_codes(rc, self._session._session) + * + * def accept_x11(self, int timeout_ms): # <<<<<<<<<<<<<< + * cdef Channel chan + * cdef c_ssh.ssh_channel _chan = NULL + */ + __pyx_tuple__18 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_timeout_ms, __pyx_n_s_chan, __pyx_n_s_chan_2); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_accept_x11, 132, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 132, __pyx_L1_error) + + /* "ssh/channel.pyx":142 + * return chan + * + * def poll(self, bint is_stderr=False): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__20 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_is_stderr, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_poll, 142, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 142, __pyx_L1_error) + __pyx_tuple__22 = PyTuple_Pack(1, Py_False); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "ssh/channel.pyx":148 + * return handle_error_codes(rc, self._session._session) + * + * def poll_timeout(self, int timeout, bint is_stderr=False): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__23 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_timeout, __pyx_n_s_is_stderr, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_poll_timeout, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 148, __pyx_L1_error) + + /* "ssh/channel.pyx":155 + * return handle_error_codes(rc, self._session._session) + * + * def read(self, c_ssh.uint32_t size=1024*1024, bint is_stderr=False): # <<<<<<<<<<<<<< + * cdef int rc + * cdef bytes buf = b'' + */ + __pyx_tuple__25 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_size, __pyx_n_s_is_stderr, __pyx_n_s_rc, __pyx_n_s_buf, __pyx_n_s_cbuf); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_read, 155, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_tuple__27 = PyTuple_Pack(2, __pyx_int_1048576, Py_False); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + + /* "ssh/channel.pyx":172 + * return handle_error_codes(rc, self._session._session), buf + * + * def read_nonblocking(self, c_ssh.uint32_t size=1024*1024, # <<<<<<<<<<<<<< + * bint is_stderr=False): + * cdef int rc + */ + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_read_nonblocking, 172, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 172, __pyx_L1_error) + + /* "ssh/channel.pyx":191 + * return handle_error_codes(rc, self._session._session), buf + * + * def read_timeout(self, int timeout, # <<<<<<<<<<<<<< + * c_ssh.uint32_t size=1024*1024, bint is_stderr=False): + * cdef int rc + */ + __pyx_tuple__29 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_timeout, __pyx_n_s_size, __pyx_n_s_is_stderr, __pyx_n_s_rc, __pyx_n_s_buf, __pyx_n_s_cbuf); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_read_timeout, 191, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 191, __pyx_L1_error) + + /* "ssh/channel.pyx":210 + * return handle_error_codes(rc, self._session._session), buf + * + * def request_env(self, name, value): # <<<<<<<<<<<<<< + * cdef bytes b_name = to_bytes(name) + * cdef const_char *c_name = b_name + */ + __pyx_tuple__31 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_b_name, __pyx_n_s_c_name, __pyx_n_s_b_value, __pyx_n_s_c_value, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_env, 210, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 210, __pyx_L1_error) + + /* "ssh/channel.pyx":220 + * return handle_error_codes(rc, self._session._session) + * + * def request_exec(self, cmd): # <<<<<<<<<<<<<< + * cdef bytes b_cmd = to_bytes(cmd) + * cdef const_char *c_cmd = b_cmd + */ + __pyx_tuple__33 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_cmd, __pyx_n_s_b_cmd, __pyx_n_s_c_cmd, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_exec, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 220, __pyx_L1_error) + + /* "ssh/channel.pyx":228 + * return handle_error_codes(rc, self._session._session) + * + * def request_pty(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_pty, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 228, __pyx_L1_error) + + /* "ssh/channel.pyx":234 + * return handle_error_codes(rc, self._session._session) + * + * def change_pty_size(self, int cols, int rows): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__36 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cols, __pyx_n_s_rows, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__36); + __Pyx_GIVEREF(__pyx_tuple__36); + __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_change_pty_size, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 234, __pyx_L1_error) + + /* "ssh/channel.pyx":240 + * return handle_error_codes(rc, self._session._session) + * + * def request_pty_size(self, terminal, int col, int row): # <<<<<<<<<<<<<< + * cdef bytes b_terminal = to_bytes(terminal) + * cdef const_char *c_terminal = b_terminal + */ + __pyx_tuple__38 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_terminal, __pyx_n_s_col, __pyx_n_s_row, __pyx_n_s_b_terminal, __pyx_n_s_c_terminal, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__38); + __Pyx_GIVEREF(__pyx_tuple__38); + __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_pty_size, 240, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 240, __pyx_L1_error) + + /* "ssh/channel.pyx":249 + * return handle_error_codes(rc, self._session._session) + * + * def request_send_signal(self, sig): # <<<<<<<<<<<<<< + * cdef bytes b_sig = to_bytes(sig) + * cdef const_char *c_sig = b_sig + */ + __pyx_tuple__40 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_sig, __pyx_n_s_b_sig, __pyx_n_s_c_sig, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__40); + __Pyx_GIVEREF(__pyx_tuple__40); + __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_send_signal, 249, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 249, __pyx_L1_error) + + /* "ssh/channel.pyx":258 + * return handle_error_codes(rc, self._session._session) + * + * def request_send_break(self, c_ssh.uint32_t length): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__42 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_length, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__42); + __Pyx_GIVEREF(__pyx_tuple__42); + __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__42, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_send_break, 258, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 258, __pyx_L1_error) + + /* "ssh/channel.pyx":265 + * return handle_error_codes(rc, self._session._session) + * + * def request_shell(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_shell, 265, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 265, __pyx_L1_error) + + /* "ssh/channel.pyx":271 + * return handle_error_codes(rc, self._session._session) + * + * def request_sftp(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_sftp, 271, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 271, __pyx_L1_error) + + /* "ssh/channel.pyx":277 + * return handle_error_codes(rc, self._session._session) + * + * def request_subsystem(self, subsystem): # <<<<<<<<<<<<<< + * cdef bytes b_sys = to_bytes(subsystem) + * cdef const_char *c_sys = b_sys + */ + __pyx_tuple__46 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_subsystem, __pyx_n_s_b_sys, __pyx_n_s_c_sys, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__46); + __Pyx_GIVEREF(__pyx_tuple__46); + __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_subsystem, 277, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(0, 277, __pyx_L1_error) + + /* "ssh/channel.pyx":286 + * return handle_error_codes(rc, self._session._session) + * + * def request_x11(self, int screen_number, bint single_connection=True): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__48 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_screen_number, __pyx_n_s_single_connection, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__48); + __Pyx_GIVEREF(__pyx_tuple__48); + __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_request_x11, 286, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 286, __pyx_L1_error) + __pyx_tuple__50 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__50); + __Pyx_GIVEREF(__pyx_tuple__50); + + /* "ssh/channel.pyx":293 + * return handle_error_codes(rc, self._session._session) + * + * def set_blocking(self, bint blocking): # <<<<<<<<<<<<<< + * with nogil: + * c_ssh.ssh_channel_set_blocking(self._channel, blocking) + */ + __pyx_tuple__51 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_blocking); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__51, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_set_blocking, 293, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(0, 293, __pyx_L1_error) + + /* "ssh/channel.pyx":297 + * c_ssh.ssh_channel_set_blocking(self._channel, blocking) + * + * def set_counter(self, counter): # <<<<<<<<<<<<<< + * raise NotImplementedError + * + */ + __pyx_tuple__53 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_counter); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__53); + __Pyx_GIVEREF(__pyx_tuple__53); + __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__53, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_set_counter, 297, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(0, 297, __pyx_L1_error) + + /* "ssh/channel.pyx":300 + * raise NotImplementedError + * + * def write(self, data not None): # <<<<<<<<<<<<<< + * """Write data to stdin on channel. + * + */ + __pyx_tuple__55 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_data, __pyx_n_s_b_buf, __pyx_n_s_buf_2, __pyx_n_s_buf_remainder, __pyx_n_s_buf_tot_size, __pyx_n_s_bytes_written, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__55); + __Pyx_GIVEREF(__pyx_tuple__55); + __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_write, 300, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(0, 300, __pyx_L1_error) + + /* "ssh/channel.pyx":329 + * return rc, bytes_written + * + * def write_stderr(self, data not None): # <<<<<<<<<<<<<< + * """Write data to stderr. + * + */ + __pyx_codeobj__57 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_write_stderr, 329, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__57)) __PYX_ERR(0, 329, __pyx_L1_error) + + /* "ssh/channel.pyx":358 + * return rc, bytes_written + * + * def window_size(self): # <<<<<<<<<<<<<< + * cdef c_ssh.uint32_t size + * with nogil: + */ + __pyx_tuple__58 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_size); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__58); + __Pyx_GIVEREF(__pyx_tuple__58); + __pyx_codeobj__59 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__58, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_window_size, 358, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__59)) __PYX_ERR(0, 358, __pyx_L1_error) + + /* "ssh/channel.pyx":364 + * return size + * + * def select(self, channels not None, outchannels not None, maxfd, # <<<<<<<<<<<<<< + * readfds, timeout=None): + * raise NotImplementedError + */ + __pyx_tuple__60 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_channels, __pyx_n_s_outchannels, __pyx_n_s_maxfd, __pyx_n_s_readfds, __pyx_n_s_timeout); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__60); + __Pyx_GIVEREF(__pyx_tuple__60); + __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__60, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_channel_pyx, __pyx_n_s_select, 364, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(0, 364, __pyx_L1_error) + __pyx_tuple__62 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__62); + __Pyx_GIVEREF(__pyx_tuple__62); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__63 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__63)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_tuple__64 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__64); + __Pyx_GIVEREF(__pyx_tuple__64); + __pyx_codeobj__65 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__64, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__65)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1048576 = PyInt_FromLong(1048576L); if (unlikely(!__pyx_int_1048576)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + 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_3ssh_7channel_Channel = &__pyx_vtable_3ssh_7channel_Channel; + __pyx_vtable_3ssh_7channel_Channel.from_ptr = (struct __pyx_obj_3ssh_7channel_Channel *(*)(ssh_channel, struct __pyx_obj_3ssh_7session_Session *))__pyx_f_3ssh_7channel_7Channel_from_ptr; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_3ssh_7channel_Channel = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_7channel_Channel_spec, NULL); if (unlikely(!__pyx_ptype_3ssh_7channel_Channel)) __PYX_ERR(0, 27, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_7channel_Channel_spec, __pyx_ptype_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #else + __pyx_ptype_3ssh_7channel_Channel = &__pyx_type_3ssh_7channel_Channel; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_7channel_Channel->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_7channel_Channel->tp_dictoffset && __pyx_ptype_3ssh_7channel_Channel->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_7channel_Channel->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_3ssh_7channel_Channel, __pyx_vtabptr_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Channel, (PyObject *) __pyx_ptype_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_7channel_Channel) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule("ssh.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(3, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_3ssh_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_3ssh_5utils_to_str, "PyObject *(char const *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_channel(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_channel}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "channel", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initchannel(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initchannel(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_channel(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_channel(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_channel(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'channel' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("channel", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "channel" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_channel(void)", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_ssh__channel) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "ssh.channel")) { + if (unlikely((PyDict_SetItemString(modules, "ssh.channel", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "ssh/channel.pyx":49 + * return chan + * + * def close(self): # <<<<<<<<<<<<<< + * cdef int rc + * if self.closed: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_5close, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_close, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_close, __pyx_t_2) < 0) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":59 + * return handle_error_codes(rc, self._session._session) + * + * def get_exit_status(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_7get_exit_status, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_get_exit_status, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_get_exit_status, __pyx_t_2) < 0) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":65 + * return rc + * + * def get_session(self): # <<<<<<<<<<<<<< + * return self.session + * + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_9get_session, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_get_session, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_get_session, __pyx_t_2) < 0) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":68 + * return self.session + * + * def is_closed(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_11is_closed, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_is_closed, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_is_closed, __pyx_t_2) < 0) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":74 + * return rc != 0 + * + * def is_eof(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_13is_eof, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_is_eof, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_is_eof, __pyx_t_2) < 0) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":80 + * return bool(rc) + * + * def is_open(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_15is_open, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_is_open, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_is_open, __pyx_t_2) < 0) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":86 + * return bool(rc) + * + * def send_eof(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_17send_eof, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_send_eof, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_send_eof, __pyx_t_2) < 0) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":92 + * return handle_error_codes(rc, self._session._session) + * + * def request_auth_agent(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_19request_auth_agent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_auth_agent, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_auth_agent, __pyx_t_2) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":98 + * return handle_error_codes(rc, self._session._session) + * + * def open_auth_agent(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_21open_auth_agent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_open_auth_agent, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_open_auth_agent, __pyx_t_2) < 0) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":104 + * return handle_error_codes(rc, self._session._session) + * + * def open_forward(self, remotehost, int remoteport, # <<<<<<<<<<<<<< + * sourcehost, int sourceport): + * cdef bytes b_remotehost = to_bytes(remotehost) + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_23open_forward, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_open_forward, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_open_forward, __pyx_t_2) < 0) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":117 + * return handle_error_codes(rc, self._session._session) + * + * def open_session(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_25open_session, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_open_session, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_open_session, __pyx_t_2) < 0) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":123 + * return handle_error_codes(rc, self._session._session) + * + * def open_x11(self, sourcehost, int sourceport): # <<<<<<<<<<<<<< + * cdef bytes b_sourcehost = to_bytes(sourcehost) + * cdef const_char *c_sourcehost = b_sourcehost + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_27open_x11, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_open_x11, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_open_x11, __pyx_t_2) < 0) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":132 + * return handle_error_codes(rc, self._session._session) + * + * def accept_x11(self, int timeout_ms): # <<<<<<<<<<<<<< + * cdef Channel chan + * cdef c_ssh.ssh_channel _chan = NULL + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_29accept_x11, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_accept_x11, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_accept_x11, __pyx_t_2) < 0) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":142 + * return chan + * + * def poll(self, bint is_stderr=False): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_31poll, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_poll, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__22); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_poll, __pyx_t_2) < 0) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":148 + * return handle_error_codes(rc, self._session._session) + * + * def poll_timeout(self, int timeout, bint is_stderr=False): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_33poll_timeout, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_poll_timeout, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__22); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_poll_timeout, __pyx_t_2) < 0) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":155 + * return handle_error_codes(rc, self._session._session) + * + * def read(self, c_ssh.uint32_t size=1024*1024, bint is_stderr=False): # <<<<<<<<<<<<<< + * cdef int rc + * cdef bytes buf = b'' + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_35read, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_read, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__27); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_read, __pyx_t_2) < 0) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":172 + * return handle_error_codes(rc, self._session._session), buf + * + * def read_nonblocking(self, c_ssh.uint32_t size=1024*1024, # <<<<<<<<<<<<<< + * bint is_stderr=False): + * cdef int rc + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_37read_nonblocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_read_nonblocking, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__27); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_read_nonblocking, __pyx_t_2) < 0) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":191 + * return handle_error_codes(rc, self._session._session), buf + * + * def read_timeout(self, int timeout, # <<<<<<<<<<<<<< + * c_ssh.uint32_t size=1024*1024, bint is_stderr=False): + * cdef int rc + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_39read_timeout, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_read_timeout, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__27); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_read_timeout, __pyx_t_2) < 0) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":210 + * return handle_error_codes(rc, self._session._session), buf + * + * def request_env(self, name, value): # <<<<<<<<<<<<<< + * cdef bytes b_name = to_bytes(name) + * cdef const_char *c_name = b_name + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_41request_env, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_env, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_env, __pyx_t_2) < 0) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":220 + * return handle_error_codes(rc, self._session._session) + * + * def request_exec(self, cmd): # <<<<<<<<<<<<<< + * cdef bytes b_cmd = to_bytes(cmd) + * cdef const_char *c_cmd = b_cmd + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_43request_exec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_exec, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_exec, __pyx_t_2) < 0) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":228 + * return handle_error_codes(rc, self._session._session) + * + * def request_pty(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_45request_pty, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_pty, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_pty, __pyx_t_2) < 0) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":234 + * return handle_error_codes(rc, self._session._session) + * + * def change_pty_size(self, int cols, int rows): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_47change_pty_size, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_change_pty_size, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_change_pty_size, __pyx_t_2) < 0) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":240 + * return handle_error_codes(rc, self._session._session) + * + * def request_pty_size(self, terminal, int col, int row): # <<<<<<<<<<<<<< + * cdef bytes b_terminal = to_bytes(terminal) + * cdef const_char *c_terminal = b_terminal + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_49request_pty_size, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_pty_size, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_pty_size, __pyx_t_2) < 0) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":249 + * return handle_error_codes(rc, self._session._session) + * + * def request_send_signal(self, sig): # <<<<<<<<<<<<<< + * cdef bytes b_sig = to_bytes(sig) + * cdef const_char *c_sig = b_sig + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_51request_send_signal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_send_signal, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_send_signal, __pyx_t_2) < 0) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":258 + * return handle_error_codes(rc, self._session._session) + * + * def request_send_break(self, c_ssh.uint32_t length): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_53request_send_break, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_send_break, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_send_break, __pyx_t_2) < 0) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":265 + * return handle_error_codes(rc, self._session._session) + * + * def request_shell(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_55request_shell, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_shell, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_shell, __pyx_t_2) < 0) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":271 + * return handle_error_codes(rc, self._session._session) + * + * def request_sftp(self): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_57request_sftp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_sftp, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_sftp, __pyx_t_2) < 0) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":277 + * return handle_error_codes(rc, self._session._session) + * + * def request_subsystem(self, subsystem): # <<<<<<<<<<<<<< + * cdef bytes b_sys = to_bytes(subsystem) + * cdef const_char *c_sys = b_sys + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_59request_subsystem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_subsystem, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__47)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_subsystem, __pyx_t_2) < 0) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":286 + * return handle_error_codes(rc, self._session._session) + * + * def request_x11(self, int screen_number, bint single_connection=True): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_61request_x11, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_x11, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__50); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_request_x11, __pyx_t_2) < 0) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":293 + * return handle_error_codes(rc, self._session._session) + * + * def set_blocking(self, bint blocking): # <<<<<<<<<<<<<< + * with nogil: + * c_ssh.ssh_channel_set_blocking(self._channel, blocking) + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_63set_blocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_set_blocking, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__52)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_set_blocking, __pyx_t_2) < 0) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":297 + * c_ssh.ssh_channel_set_blocking(self._channel, blocking) + * + * def set_counter(self, counter): # <<<<<<<<<<<<<< + * raise NotImplementedError + * + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_65set_counter, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_set_counter, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__54)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_set_counter, __pyx_t_2) < 0) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":300 + * raise NotImplementedError + * + * def write(self, data not None): # <<<<<<<<<<<<<< + * """Write data to stdin on channel. + * + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_67write, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_write, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__56)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_write, __pyx_t_2) < 0) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":329 + * return rc, bytes_written + * + * def write_stderr(self, data not None): # <<<<<<<<<<<<<< + * """Write data to stderr. + * + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_69write_stderr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_write_stderr, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__57)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 329, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_write_stderr, __pyx_t_2) < 0) __PYX_ERR(0, 329, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":358 + * return rc, bytes_written + * + * def window_size(self): # <<<<<<<<<<<<<< + * cdef c_ssh.uint32_t size + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_71window_size, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_window_size, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__59)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_window_size, __pyx_t_2) < 0) __PYX_ERR(0, 358, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "ssh/channel.pyx":364 + * return size + * + * def select(self, channels not None, outchannels not None, maxfd, # <<<<<<<<<<<<<< + * readfds, timeout=None): + * raise NotImplementedError + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_73select, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_select, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__61)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__62); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_7channel_Channel, __pyx_n_s_select, __pyx_t_2) < 0) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_7channel_Channel); + + /* "(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_3ssh_7channel_7Channel_75__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel___reduce_cython, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__63)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_7channel_7Channel_77__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel___setstate_cython, NULL, __pyx_n_s_ssh_channel, __pyx_d, ((PyObject *)__pyx_codeobj__65)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "ssh/channel.pyx":1 + * # This file is part of ssh-python. # <<<<<<<<<<<<<< + * # Copyright (C) 2018 Panos Kittenis + * # + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init ssh.channel", __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 ssh.channel"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + Py_XDECREF(key); + Py_XDECREF(value); + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; +#endif + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + goto invalid_keyword; + } +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } +#endif + return 1; + } + while (PyDict_Next(kw, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if (!kw_allowed && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +/* 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 >= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #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); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* 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 */ +#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 */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { + #if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} #endif + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); #else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; #else -#define __Pyx_PyMODINIT_FUNC PyObject * + type->tp_print = (printfunc) memb->offset; #endif + changed = 1; + } #endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initchannel(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initchannel(void) #else -__Pyx_PyMODINIT_FUNC PyInit_channel(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_channel(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); } +#endif return 0; } -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; +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); - modname = PyObject_GetAttrString(spec, "name"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_channel(PyObject *__pyx_pyinit_module) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; #endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && #endif -{ - PyObject *__pyx_t_1 = 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 'channel' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_channel(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("channel", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_ssh__channel) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "ssh.channel")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.channel", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "ssh/channel.pyx":1 - * # This file is part of ssh-python. # <<<<<<<<<<<<<< - * # Copyright (C) 2018 Panos Kittenis - * # - */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init ssh.channel", __pyx_clineno, __pyx_lineno, __pyx_filename); + else { + d = NULL; + nd = 0; } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init ssh.channel"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; } +#endif -/* --- 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; +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; } #endif -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; } #endif -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); return result; } - -/* RaiseDoubleKeywords */ -static void __Pyx_RaiseDoubleKeywordsError( - const char* func_name, - PyObject* kw_name) -{ - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION >= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); + vectorcallfunc f = PyVectorcall_Function(func); #endif -} - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - while (PyDict_Next(kwds, &pos, &key, &value)) { - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; - continue; + if (f) { + return f(func, args, (size_t)nargs, NULL); } - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = (**name == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); } + #endif } - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION < 3 - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); #else - "%s() got an unexpected keyword argument '%U'", - function_name, key); + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); #endif -bad: - return -1; } -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) -{ - Py_ssize_t num_expected; - const char *more_or_less; - if (num_found < num_min) { - num_expected = num_min; - more_or_less = "at least"; - } else { - num_expected = num_max; - more_or_less = "at most"; - } - if (exact) { - more_or_less = "exactly"; - } - PyErr_Format(PyExc_TypeError, - "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", - func_name, more_or_less, num_expected, - (num_expected == 1) ? "" : "s", num_found); +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} #endif -/* GetException */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); #else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; #endif -{ - PyObject *local_type, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - local_type = tstate->curexc_type; - local_value = tstate->curexc_value; - local_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; #else - PyErr_Fetch(&local_type, &local_value, &local_tb); + (void)__Pyx_PyObject_CallMethod0; #endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); #else - if (unlikely(PyErr_Occurred())) + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); #endif - goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; + __Pyx_DECREF_TypeName(type_name); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif - Py_XINCREF(local_tb); - Py_XINCREF(local_type); - Py_XINCREF(local_value); - *type = local_type; - *value = local_value; - *tb = local_tb; -#if CYTHON_FAST_THREAD_STATE - #if CYTHON_USE_EXC_INFO_STACK { - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = local_type; - exc_info->exc_value = local_value; - exc_info->exc_traceback = local_tb; + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } } - #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); + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetVTable */ +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else - PyErr_SetExcInfo(local_type, local_value, local_tb); + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif + goto bad; + Py_DECREF(ob); return 0; bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); + Py_XDECREF(ob); return -1; } -/* SwapException */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = *type; - exc_info->exc_value = *value; - exc_info->exc_traceback = *tb; - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = *type; - tstate->exc_value = *value; - tstate->exc_traceback = *tb; - #endif - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; -} +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); #else -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; -} + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); #endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) -{ - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && - exc_info->previous_item != NULL) +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; { - exc_info = exc_info->previous_item; + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; + } } - 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 - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - *type = exc_info->exc_type; - *value = exc_info->exc_value; - *tb = exc_info->exc_traceback; - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - #endif - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); -} -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = type; - exc_info->exc_value = value; - exc_info->exc_traceback = tb; - #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); + base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { + void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); + if (base_vtable != NULL) { + int j; + PyTypeObject* base = type->tp_base; + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = base->tp_base; + } + } + } + PyErr_Clear(); + free(base_vtables); + return 0; +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; } #endif -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { - __Pyx_PyThreadState_declare - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } #endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; } } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else -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; + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; } } + PyType_Modified((PyTypeObject*)type_obj); } - 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; - } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} +#endif + +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + PyObject *py_itemsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#if !CYTHON_COMPILING_IN_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize+itemsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } - 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"); + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { goto bad; } - PyException_SetCause(value, fixed_cause); + goto done; } - PyErr_SetObject(type, value); - if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} #else - 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); - } +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; #endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; bad: - Py_XDECREF(owned_instance); - return; + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; } #endif -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); return NULL; - 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; + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #endif - return NULL; + 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 CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; } } - return descr; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; } +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } #endif - -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); } #endif - -/* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 - PyObject *ob = PyCapsule_New(vtable, 0, 0); +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif - if (!ob) - goto bad; - if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) - goto bad; - Py_DECREF(ob); - return 0; -bad: - Py_XDECREF(ob); - return -1; -} - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); #if PY_MAJOR_VERSION >= 3 - for (i=0; ifunc_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; } #endif - for (i=0; ifunc_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; } return 0; } -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { - PyObject *exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +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); } -#endif - -/* PyObjectGetAttrStrNoError */ -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); - } +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); } - return result; + return 0; } - -/* SetupReduce */ -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif } -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; #else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; #endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); #else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; #endif - if (object_getstate != getstate) { - goto __PYX_GOOD; + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); #endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + 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 - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); #endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_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); + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } return ret; } - -/* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { - PyObject *result = 0; - char warning[200]; - Py_ssize_t basicsize; -#ifdef Py_LIMITED_API - PyObject *py_basicsize; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - result = PyObject_GetAttrString(module, class_name); - if (!result) - goto bad; - if (!PyType_Check(result)) { + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } -#ifndef Py_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; + return def->ml_meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - if ((size_t)basicsize < size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), +#endif + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; + return op; } -#endif /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -9558,12 +16900,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -9577,7 +16920,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -9599,6 +16942,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -9677,17 +17021,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -9722,6 +17150,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -9737,7 +17166,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -9784,6 +17213,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -9820,7 +17250,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -9834,40 +17264,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -9880,109 +17315,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -10016,7 +17523,7 @@ static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(uint32_t) < sizeof(long)) { + if ((sizeof(uint32_t) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -10030,40 +17537,45 @@ static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (uint32_t) 0; - case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, digits[0]) - case 2: - if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT) { - return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(uint32_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT)) { + return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT) { - return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + break; + case 3: + if ((8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT)) { + return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) >= 4 * PyLong_SHIFT) { - return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + break; + case 4: + if ((8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) >= 4 * PyLong_SHIFT)) { + return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -10076,109 +17588,181 @@ static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(uint32_t) <= sizeof(unsigned long)) { + if ((sizeof(uint32_t) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (uint32_t) 0; - case -1: __PYX_VERIFY_RETURN_INT(uint32_t, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, +digits[0]) - case -2: - if (8 * sizeof(uint32_t) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { - return (uint32_t) (((uint32_t)-1)*(((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(uint32_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(uint32_t) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { + return (uint32_t) (((uint32_t)-1)*(((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { - return (uint32_t) ((((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + break; + case 2: + if ((8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { + return (uint32_t) ((((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { - return (uint32_t) (((uint32_t)-1)*(((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + break; + case -3: + if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { + return (uint32_t) (((uint32_t)-1)*(((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { - return (uint32_t) ((((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + break; + case 3: + if ((8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { + return (uint32_t) ((((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_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(uint32_t) - 1 > 4 * PyLong_SHIFT) { - return (uint32_t) (((uint32_t)-1)*(((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + break; + case -4: + if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_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(uint32_t) - 1 > 4 * PyLong_SHIFT)) { + return (uint32_t) (((uint32_t)-1)*(((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT) { - return (uint32_t) ((((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + break; + case 4: + if ((8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT)) { + return (uint32_t) ((((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(uint32_t) <= sizeof(long)) { + if ((sizeof(uint32_t) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(uint32_t) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else uint32_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (uint32_t) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (uint32_t) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (uint32_t) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (uint32_t) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (uint32_t) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(uint32_t) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((uint32_t) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(uint32_t) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((uint32_t) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((uint32_t) 1) << (sizeof(uint32_t) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (uint32_t) -1; } } else { @@ -10232,8 +17816,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -10270,11 +17880,53 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(uint32_t), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(uint32_t)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name_2); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__66); + } + return name; +} +#endif + /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC @@ -10308,8 +17960,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -10326,7 +18004,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -10340,40 +18018,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -10386,109 +18069,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -10513,7 +18268,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -10534,6 +18289,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -10558,11 +18329,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -10610,47 +18381,56 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionImport */ -#ifndef __PYX_HAVE_RT_ImportFunction -#define __PYX_HAVE_RT_ImportFunction -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { +#ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { @@ -10667,7 +18447,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** PyModule_GetName(module), funcname); goto bad; } -#if PY_VERSION_HEX >= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", @@ -10675,21 +18454,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); -#else - {const char *desc, *s1, *s2; - desc = (const char *)PyCObject_GetDesc(cobj); - if (!desc) - goto bad; - s1 = desc; s2 = sig; - while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } - if (*s1 != *s2) { - PyErr_Format(PyExc_TypeError, - "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", - PyModule_GetName(module), funcname, sig, desc); - goto bad; - } - tmp.p = PyCObject_AsVoidPtr(cobj);} -#endif *f = tmp.fp; if (!(*f)) goto bad; @@ -10702,9 +18466,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** #endif /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -10712,30 +18498,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -10790,7 +18580,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -10819,22 +18609,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -10900,13 +18694,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -10974,4 +18766,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/connector.c b/ssh/connector.c index 96fe3982..620ebb31 100644 --- a/ssh/connector.c +++ b/ssh/connector.c @@ -1,22 +1,89 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.connector", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/connector.pyx" + ] + }, + "module_name": "ssh.connector" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" + + #if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj) + #else + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj, NULL) + #endif + + + #if PY_MAJOR_VERSION <= 2 + #define PyDict_GetItemWithError _PyDict_GetItemWithError + #endif + + + #if (PY_VERSION_HEX < 0x030700b1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030600)) && !defined(PyContextVar_Get) + #define PyContextVar_Get(var, d, v) ((d) ? ((void)(var), Py_INCREF(d), (v)[0] = (d), 0) : ((v)[0] = NULL, 0) ) + #endif + #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +102,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +110,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +147,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +167,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +295,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +324,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +335,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +358,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +385,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +409,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +493,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +517,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +534,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +596,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +631,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +783,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +800,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +890,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +936,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +970,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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 + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1064,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1079,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1121,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1138,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1185,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1205,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1245,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -796,9 +1324,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -816,9 +1345,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -826,13 +1355,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -856,8 +1379,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -878,7 +1447,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -908,6 +1477,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -943,28 +1513,32 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { - "stringsource", + "", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/contextvars.pxd", "ssh/connector.pyx", "ssh/session.pxd", - "env/lib/python3.9/site-packages/Cython/Includes/cpython/type.pxd", - "env/lib/python3.9/site-packages/Cython/Includes/cpython/bool.pxd", - "env/lib/python3.9/site-packages/Cython/Includes/cpython/complex.pxd", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/type.pxd", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/bool.pxd", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/complex.pxd", "ssh/channel.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -972,17 +1546,41 @@ static const char *__pyx_f[] = { #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_3ssh_7session_Session; struct __pyx_obj_3ssh_7channel_Channel; struct __pyx_obj_3ssh_9connector_Flag; struct __pyx_obj_3ssh_9connector_Connector; +struct __pyx_opt_args_7cpython_11contextvars_get_value; +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default; + +/* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value { + int __pyx_n; + PyObject *default_value; +}; + +/* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default { + int __pyx_n; + PyObject *default_value; +}; /* "session.pxd":19 * cimport c_ssh @@ -1085,6 +1683,7 @@ struct __pyx_vtabstruct_3ssh_9connector_Connector { struct __pyx_obj_3ssh_9connector_Connector *(*from_ptr)(ssh_connector, struct __pyx_obj_3ssh_7session_Session *); }; static struct __pyx_vtabstruct_3ssh_9connector_Connector *__pyx_vtabptr_3ssh_9connector_Connector; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1093,11 +1692,11 @@ static struct __pyx_vtabstruct_3ssh_9connector_Connector *__pyx_vtabptr_3ssh_9co #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1107,28 +1706,40 @@ static struct __pyx_vtabstruct_3ssh_9connector_Connector *__pyx_vtabptr_3ssh_9co #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1139,6 +1750,10 @@ static struct __pyx_vtabstruct_3ssh_9connector_Connector *__pyx_vtabptr_3ssh_9co #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);\ @@ -1150,6 +1765,57 @@ static struct __pyx_vtabstruct_3ssh_9connector_Connector *__pyx_vtabptr_3ssh_9co #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); @@ -1157,51 +1823,119 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); -#else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) -#endif +/* PyObject_Str.proto */ +#define __Pyx_PyObject_Str(obj)\ + (likely(PyString_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif -#if CYTHON_FAST_PYCALL - static size_t __pyx_pyframe_localsplus_offset = 0; +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif // CYTHON_FAST_PYCALL +#endif +#endif #endif /* PyObjectCall.proto */ @@ -1216,62 +1950,16 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) -#endif - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif +/* 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); -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); @@ -1304,18 +1992,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) @@ -1327,13 +2015,13 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name); -/* RaiseArgTupleInvalid.proto */ -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); +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); @@ -1350,11 +2038,43 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 @@ -1371,27 +2091,179 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 }; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); #endif -/* GetVTable.proto */ -static void* __Pyx_GetVtable(PyObject *dict); +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK @@ -1401,6 +2273,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1414,13 +2287,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif @@ -1439,144 +2313,170 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionImport.proto */ -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self); /* proto*/ static struct __pyx_obj_3ssh_9connector_Flag *__pyx_f_3ssh_9connector_4Flag_from_flag(enum ssh_connector_flags_e __pyx_v_flag); /* proto*/ static struct __pyx_obj_3ssh_9connector_Connector *__pyx_f_3ssh_9connector_9Connector_from_ptr(ssh_connector __pyx_v__connector, struct __pyx_obj_3ssh_7session_Session *__pyx_v_session); /* proto*/ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ + +/* Module declarations from "libc.time" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.session" */ -/* Module declarations from 'ssh.session' */ -static PyTypeObject *__pyx_ptype_3ssh_7session_Session = 0; +/* Module declarations from "cpython.version" */ -/* Module declarations from 'cpython.version' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.type" */ -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from "libc.string" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'libc.stdio' */ +/* Module declarations from "cpython.object" */ -/* Module declarations from 'cpython.object' */ +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'cpython.ref' */ +/* Module declarations from "cpython.exc" */ -/* Module declarations from 'cpython.exc' */ +/* Module declarations from "cpython.module" */ -/* Module declarations from 'cpython.module' */ +/* Module declarations from "cpython.mem" */ -/* Module declarations from 'cpython.mem' */ +/* Module declarations from "cpython.tuple" */ -/* Module declarations from 'cpython.tuple' */ +/* Module declarations from "cpython.list" */ -/* Module declarations from 'cpython.list' */ +/* Module declarations from "cpython.sequence" */ -/* Module declarations from 'cpython.sequence' */ +/* Module declarations from "cpython.mapping" */ -/* Module declarations from 'cpython.mapping' */ +/* Module declarations from "cpython.iterator" */ -/* Module declarations from 'cpython.iterator' */ +/* Module declarations from "cpython.number" */ -/* Module declarations from 'cpython.number' */ +/* Module declarations from "cpython.int" */ -/* Module declarations from 'cpython.int' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.bool" */ -/* Module declarations from 'cpython.bool' */ -static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; +/* Module declarations from "cpython.long" */ -/* Module declarations from 'cpython.long' */ +/* Module declarations from "cpython.float" */ -/* Module declarations from 'cpython.float' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "cpython.complex" */ -/* Module declarations from 'cpython.complex' */ -static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; +/* Module declarations from "cpython.string" */ -/* Module declarations from 'cpython.string' */ +/* Module declarations from "cpython.unicode" */ -/* Module declarations from 'cpython.unicode' */ +/* Module declarations from "cpython.pyport" */ -/* Module declarations from 'cpython.dict' */ +/* Module declarations from "cpython.dict" */ -/* Module declarations from 'cpython.instance' */ +/* Module declarations from "cpython.instance" */ -/* Module declarations from 'cpython.function' */ +/* Module declarations from "cpython.function" */ -/* Module declarations from 'cpython.method' */ +/* Module declarations from "cpython.method" */ -/* Module declarations from 'cpython.weakref' */ +/* Module declarations from "cpython.weakref" */ -/* Module declarations from 'cpython.getargs' */ +/* Module declarations from "cpython.getargs" */ -/* Module declarations from 'cpython.pythread' */ +/* Module declarations from "cpython.pythread" */ -/* Module declarations from 'cpython.pystate' */ +/* Module declarations from "cpython.pystate" */ -/* Module declarations from 'cpython.cobject' */ +/* Module declarations from "cpython.cobject" */ -/* Module declarations from 'cpython.oldbuffer' */ +/* Module declarations from "cpython.oldbuffer" */ -/* Module declarations from 'cpython.set' */ +/* Module declarations from "cpython.set" */ -/* Module declarations from 'cpython.buffer' */ +/* Module declarations from "cpython.buffer" */ -/* Module declarations from 'cpython.bytes' */ +/* Module declarations from "cpython.bytes" */ -/* Module declarations from 'cpython.pycapsule' */ +/* Module declarations from "cpython.pycapsule" */ -/* Module declarations from 'cpython' */ +/* Module declarations from "cpython.contextvars" */ -/* Module declarations from 'ssh.channel' */ -static PyTypeObject *__pyx_ptype_3ssh_7channel_Channel = 0; +/* Module declarations from "cpython" */ -/* Module declarations from 'ssh.utils' */ +/* Module declarations from "ssh.channel" */ + +/* Module declarations from "ssh.utils" */ static int (*__pyx_f_3ssh_5utils_handle_error_codes)(int, ssh_session); /*proto*/ -/* Module declarations from 'ssh.connector' */ -static PyTypeObject *__pyx_ptype_3ssh_9connector_Flag = 0; -static PyTypeObject *__pyx_ptype_3ssh_9connector_Connector = 0; +/* Module declarations from "ssh.connector" */ static PyObject *__pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(struct __pyx_obj_3ssh_9connector_Flag *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.connector" extern int __pyx_module_is_main_ssh__connector; int __pyx_module_is_main_ssh__connector = 0; -/* Implementation of 'ssh.connector' */ +/* Implementation of "ssh.connector" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_TypeError; +/* #### Code section: string_decls ### */ +static const char __pyx_k__2[] = "."; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_rc[] = "rc"; +static const char __pyx_k__18[] = "?"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_str[] = "__str__"; static const char __pyx_k_Flag[] = "Flag"; @@ -1584,73 +2484,61 @@ static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_flag[] = "flag"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_sock[] = "_sock"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_dict_2[] = "_dict"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_socket[] = "socket"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_channel[] = "channel"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_session[] = "session"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_Connector[] = "Connector"; static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_set_in_fd[] = "set_in_fd"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_set_out_fd[] = "set_out_fd"; static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_use_setstate[] = "use_setstate"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_ssh_connector[] = "ssh.connector"; static const char __pyx_k_CONNECTOR_BOTH[] = "CONNECTOR_BOTH"; +static const char __pyx_k_set_in_channel[] = "set_in_channel"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; +static const char __pyx_k_set_out_channel[] = "set_out_channel"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_CONNECTOR_STDERR[] = "CONNECTOR_STDERR"; static const char __pyx_k_CONNECTOR_STDOUT[] = "CONNECTOR_STDOUT"; static const char __pyx_k_pyx_unpickle_Flag[] = "__pyx_unpickle_Flag"; +static const char __pyx_k_ssh_connector_pyx[] = "ssh/connector.pyx"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))"; +static const char __pyx_k_Connector_set_in_fd[] = "Connector.set_in_fd"; +static const char __pyx_k_Connector_set_out_fd[] = "Connector.set_out_fd"; +static const char __pyx_k_Flag___reduce_cython[] = "Flag.__reduce_cython__"; +static const char __pyx_k_Flag___setstate_cython[] = "Flag.__setstate_cython__"; +static const char __pyx_k_Connector_set_in_channel[] = "Connector.set_in_channel"; +static const char __pyx_k_Connector___reduce_cython[] = "Connector.__reduce_cython__"; +static const char __pyx_k_Connector_set_out_channel[] = "Connector.set_out_channel"; +static const char __pyx_k_Connector___setstate_cython[] = "Connector.__setstate_cython__"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static PyObject *__pyx_n_s_CONNECTOR_BOTH; -static PyObject *__pyx_n_s_CONNECTOR_STDERR; -static PyObject *__pyx_n_s_CONNECTOR_STDOUT; -static PyObject *__pyx_n_s_Connector; -static PyObject *__pyx_n_s_Flag; -static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; -static PyObject *__pyx_n_s_PickleError; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_n_s_channel; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_dict; -static PyObject *__pyx_n_s_flag; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_new; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_n_s_pickle; -static PyObject *__pyx_n_s_pyx_PickleError; -static PyObject *__pyx_n_s_pyx_checksum; -static PyObject *__pyx_n_s_pyx_result; -static PyObject *__pyx_n_s_pyx_state; -static PyObject *__pyx_n_s_pyx_type; -static PyObject *__pyx_n_s_pyx_unpickle_Flag; -static PyObject *__pyx_n_s_pyx_vtable; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_session; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_ssh_connector; -static PyObject *__pyx_n_s_str; -static PyObject *__pyx_kp_s_stringsource; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_update; +/* #### Code section: decls ### */ static PyObject *__pyx_pf_3ssh_9connector_4Flag___eq__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self, struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_other); /* proto */ static PyObject *__pyx_pf_3ssh_9connector_4Flag_2__str__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_9connector_4Flag_4__repr__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self); /* proto */ @@ -1668,180 +2556,1158 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_14__setstate_cython__(CYTHO static PyObject *__pyx_pf_3ssh_9connector___pyx_unpickle_Flag(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_3ssh_9connector_Flag(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_3ssh_9connector_Connector(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_int_93404209; -static PyObject *__pyx_int_233791475; -static PyObject *__pyx_int_242378367; -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__4; -static PyObject *__pyx_codeobj__5; -/* Late includes */ - -/* "ssh/connector.pyx":29 - * - * @staticmethod - * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): # <<<<<<<<<<<<<< - * cdef Flag _flag = Flag.__new__(Flag) - * _flag._flag = flag - */ - -static struct __pyx_obj_3ssh_9connector_Flag *__pyx_f_3ssh_9connector_4Flag_from_flag(enum ssh_connector_flags_e __pyx_v_flag) { - struct __pyx_obj_3ssh_9connector_Flag *__pyx_v__flag = 0; - struct __pyx_obj_3ssh_9connector_Flag *__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("from_flag", 0); - - /* "ssh/connector.pyx":30 - * @staticmethod - * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): - * cdef Flag _flag = Flag.__new__(Flag) # <<<<<<<<<<<<<< - * _flag._flag = flag - * return _flag - */ - __pyx_t_1 = ((PyObject *)__pyx_tp_new_3ssh_9connector_Flag(((PyTypeObject *)__pyx_ptype_3ssh_9connector_Flag), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 30, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_1)); - __pyx_v__flag = ((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_t_1); - __pyx_t_1 = 0; - - /* "ssh/connector.pyx":31 - * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): - * cdef Flag _flag = Flag.__new__(Flag) - * _flag._flag = flag # <<<<<<<<<<<<<< - * return _flag +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_3ssh_7session_Session; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4bool_bool; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_7complex_complex; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_3ssh_7channel_Channel; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_3ssh_9connector_Flag; + PyObject *__pyx_type_3ssh_9connector_Connector; + #endif + PyTypeObject *__pyx_ptype_3ssh_9connector_Flag; + PyTypeObject *__pyx_ptype_3ssh_9connector_Connector; + PyObject *__pyx_n_s_CONNECTOR_BOTH; + PyObject *__pyx_n_s_CONNECTOR_STDERR; + PyObject *__pyx_n_s_CONNECTOR_STDOUT; + PyObject *__pyx_n_s_Connector; + PyObject *__pyx_n_s_Connector___reduce_cython; + PyObject *__pyx_n_s_Connector___setstate_cython; + PyObject *__pyx_n_s_Connector_set_in_channel; + PyObject *__pyx_n_s_Connector_set_in_fd; + PyObject *__pyx_n_s_Connector_set_out_channel; + PyObject *__pyx_n_s_Connector_set_out_fd; + PyObject *__pyx_n_s_Flag; + PyObject *__pyx_n_s_Flag___reduce_cython; + PyObject *__pyx_n_s_Flag___setstate_cython; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; + PyObject *__pyx_n_s_PickleError; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s__18; + PyObject *__pyx_kp_u__2; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_channel; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_n_s_dict_2; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_flag; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_new; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_pickle; + PyObject *__pyx_n_s_pyx_PickleError; + PyObject *__pyx_n_s_pyx_checksum; + PyObject *__pyx_n_s_pyx_result; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_type; + PyObject *__pyx_n_s_pyx_unpickle_Flag; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_rc; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_session; + PyObject *__pyx_n_s_set_in_channel; + PyObject *__pyx_n_s_set_in_fd; + PyObject *__pyx_n_s_set_out_channel; + PyObject *__pyx_n_s_set_out_fd; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_sock; + PyObject *__pyx_n_s_socket; + PyObject *__pyx_n_s_ssh_connector; + PyObject *__pyx_kp_s_ssh_connector_pyx; + PyObject *__pyx_n_s_state; + PyObject *__pyx_n_s_str; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_update; + PyObject *__pyx_n_s_use_setstate; + PyObject *__pyx_int_93404209; + PyObject *__pyx_int_233791475; + PyObject *__pyx_int_242378367; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__5; + PyObject *__pyx_tuple__7; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__13; + PyObject *__pyx_tuple__16; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__6; + PyObject *__pyx_codeobj__8; + PyObject *__pyx_codeobj__9; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__12; + PyObject *__pyx_codeobj__14; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__17; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_7session_Session); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4bool_bool); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_7complex_complex); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_7channel_Channel); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_9connector_Flag); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_9connector_Flag); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_9connector_Connector); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_9connector_Connector); + Py_CLEAR(clear_module_state->__pyx_n_s_CONNECTOR_BOTH); + Py_CLEAR(clear_module_state->__pyx_n_s_CONNECTOR_STDERR); + Py_CLEAR(clear_module_state->__pyx_n_s_CONNECTOR_STDOUT); + Py_CLEAR(clear_module_state->__pyx_n_s_Connector); + Py_CLEAR(clear_module_state->__pyx_n_s_Connector___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Connector___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Connector_set_in_channel); + Py_CLEAR(clear_module_state->__pyx_n_s_Connector_set_in_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_Connector_set_out_channel); + Py_CLEAR(clear_module_state->__pyx_n_s_Connector_set_out_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_Flag); + Py_CLEAR(clear_module_state->__pyx_n_s_Flag___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Flag___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s__18); + Py_CLEAR(clear_module_state->__pyx_kp_u__2); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_channel); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_flag); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_new); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_pickle); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Flag); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_rc); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_session); + Py_CLEAR(clear_module_state->__pyx_n_s_set_in_channel); + Py_CLEAR(clear_module_state->__pyx_n_s_set_in_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_set_out_channel); + Py_CLEAR(clear_module_state->__pyx_n_s_set_out_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_sock); + Py_CLEAR(clear_module_state->__pyx_n_s_socket); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_connector); + Py_CLEAR(clear_module_state->__pyx_kp_s_ssh_connector_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_state); + Py_CLEAR(clear_module_state->__pyx_n_s_str); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_update); + Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); + Py_CLEAR(clear_module_state->__pyx_int_93404209); + Py_CLEAR(clear_module_state->__pyx_int_233791475); + Py_CLEAR(clear_module_state->__pyx_int_242378367); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__5); + Py_CLEAR(clear_module_state->__pyx_tuple__7); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__6); + Py_CLEAR(clear_module_state->__pyx_codeobj__8); + Py_CLEAR(clear_module_state->__pyx_codeobj__9); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__12); + Py_CLEAR(clear_module_state->__pyx_codeobj__14); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_7session_Session); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4bool_bool); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_7complex_complex); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_7channel_Channel); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_9connector_Flag); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_9connector_Flag); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_9connector_Connector); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_9connector_Connector); + Py_VISIT(traverse_module_state->__pyx_n_s_CONNECTOR_BOTH); + Py_VISIT(traverse_module_state->__pyx_n_s_CONNECTOR_STDERR); + Py_VISIT(traverse_module_state->__pyx_n_s_CONNECTOR_STDOUT); + Py_VISIT(traverse_module_state->__pyx_n_s_Connector); + Py_VISIT(traverse_module_state->__pyx_n_s_Connector___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Connector___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Connector_set_in_channel); + Py_VISIT(traverse_module_state->__pyx_n_s_Connector_set_in_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_Connector_set_out_channel); + Py_VISIT(traverse_module_state->__pyx_n_s_Connector_set_out_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_Flag); + Py_VISIT(traverse_module_state->__pyx_n_s_Flag___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Flag___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s__18); + Py_VISIT(traverse_module_state->__pyx_kp_u__2); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_channel); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_flag); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_new); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_pickle); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Flag); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_rc); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_session); + Py_VISIT(traverse_module_state->__pyx_n_s_set_in_channel); + Py_VISIT(traverse_module_state->__pyx_n_s_set_in_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_set_out_channel); + Py_VISIT(traverse_module_state->__pyx_n_s_set_out_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_sock); + Py_VISIT(traverse_module_state->__pyx_n_s_socket); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_connector); + Py_VISIT(traverse_module_state->__pyx_kp_s_ssh_connector_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_state); + Py_VISIT(traverse_module_state->__pyx_n_s_str); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_update); + Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); + Py_VISIT(traverse_module_state->__pyx_int_93404209); + Py_VISIT(traverse_module_state->__pyx_int_233791475); + Py_VISIT(traverse_module_state->__pyx_int_242378367); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__5); + Py_VISIT(traverse_module_state->__pyx_tuple__7); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__6); + Py_VISIT(traverse_module_state->__pyx_codeobj__8); + Py_VISIT(traverse_module_state->__pyx_codeobj__9); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__12); + Py_VISIT(traverse_module_state->__pyx_codeobj__14); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_3ssh_7session_Session __pyx_mstate_global->__pyx_ptype_3ssh_7session_Session +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4bool_bool __pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_7complex_complex __pyx_mstate_global->__pyx_ptype_7cpython_7complex_complex +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_3ssh_7channel_Channel __pyx_mstate_global->__pyx_ptype_3ssh_7channel_Channel +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_3ssh_9connector_Flag __pyx_mstate_global->__pyx_type_3ssh_9connector_Flag +#define __pyx_type_3ssh_9connector_Connector __pyx_mstate_global->__pyx_type_3ssh_9connector_Connector +#endif +#define __pyx_ptype_3ssh_9connector_Flag __pyx_mstate_global->__pyx_ptype_3ssh_9connector_Flag +#define __pyx_ptype_3ssh_9connector_Connector __pyx_mstate_global->__pyx_ptype_3ssh_9connector_Connector +#define __pyx_n_s_CONNECTOR_BOTH __pyx_mstate_global->__pyx_n_s_CONNECTOR_BOTH +#define __pyx_n_s_CONNECTOR_STDERR __pyx_mstate_global->__pyx_n_s_CONNECTOR_STDERR +#define __pyx_n_s_CONNECTOR_STDOUT __pyx_mstate_global->__pyx_n_s_CONNECTOR_STDOUT +#define __pyx_n_s_Connector __pyx_mstate_global->__pyx_n_s_Connector +#define __pyx_n_s_Connector___reduce_cython __pyx_mstate_global->__pyx_n_s_Connector___reduce_cython +#define __pyx_n_s_Connector___setstate_cython __pyx_mstate_global->__pyx_n_s_Connector___setstate_cython +#define __pyx_n_s_Connector_set_in_channel __pyx_mstate_global->__pyx_n_s_Connector_set_in_channel +#define __pyx_n_s_Connector_set_in_fd __pyx_mstate_global->__pyx_n_s_Connector_set_in_fd +#define __pyx_n_s_Connector_set_out_channel __pyx_mstate_global->__pyx_n_s_Connector_set_out_channel +#define __pyx_n_s_Connector_set_out_fd __pyx_mstate_global->__pyx_n_s_Connector_set_out_fd +#define __pyx_n_s_Flag __pyx_mstate_global->__pyx_n_s_Flag +#define __pyx_n_s_Flag___reduce_cython __pyx_mstate_global->__pyx_n_s_Flag___reduce_cython +#define __pyx_n_s_Flag___setstate_cython __pyx_mstate_global->__pyx_n_s_Flag___setstate_cython +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 +#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s__18 __pyx_mstate_global->__pyx_n_s__18 +#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_channel __pyx_mstate_global->__pyx_n_s_channel +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_flag __pyx_mstate_global->__pyx_n_s_flag +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle +#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError +#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum +#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type +#define __pyx_n_s_pyx_unpickle_Flag __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Flag +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session +#define __pyx_n_s_set_in_channel __pyx_mstate_global->__pyx_n_s_set_in_channel +#define __pyx_n_s_set_in_fd __pyx_mstate_global->__pyx_n_s_set_in_fd +#define __pyx_n_s_set_out_channel __pyx_mstate_global->__pyx_n_s_set_out_channel +#define __pyx_n_s_set_out_fd __pyx_mstate_global->__pyx_n_s_set_out_fd +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_sock __pyx_mstate_global->__pyx_n_s_sock +#define __pyx_n_s_socket __pyx_mstate_global->__pyx_n_s_socket +#define __pyx_n_s_ssh_connector __pyx_mstate_global->__pyx_n_s_ssh_connector +#define __pyx_kp_s_ssh_connector_pyx __pyx_mstate_global->__pyx_kp_s_ssh_connector_pyx +#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state +#define __pyx_n_s_str __pyx_mstate_global->__pyx_n_s_str +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update +#define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate +#define __pyx_int_93404209 __pyx_mstate_global->__pyx_int_93404209 +#define __pyx_int_233791475 __pyx_mstate_global->__pyx_int_233791475 +#define __pyx_int_242378367 __pyx_mstate_global->__pyx_int_242378367 +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 +#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 +#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8 +#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12 +#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +/* #### Code section: module_code ### */ + +/* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real * */ - __pyx_v__flag->_flag = __pyx_v_flag; - /* "ssh/connector.pyx":32 - * cdef Flag _flag = Flag.__new__(Flag) - * _flag._flag = flag - * return _flag # <<<<<<<<<<<<<< +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self) { + double __pyx_r; + + /* "cpython/complex.pxd":20 + * @property + * cdef inline double real(self) noexcept: + * return self.cval.real # <<<<<<<<<<<<<< * - * def __eq__(self, Flag other not None): + * @property */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v__flag)); - __pyx_r = __pyx_v__flag; + __pyx_r = __pyx_v_self->cval.real; goto __pyx_L0; - /* "ssh/connector.pyx":29 + /* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real * - * @staticmethod - * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): # <<<<<<<<<<<<<< - * cdef Flag _flag = Flag.__new__(Flag) - * _flag._flag = flag */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("ssh.connector.Flag.from_flag", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v__flag); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "ssh/connector.pyx":34 - * return _flag +/* "cpython/complex.pxd":23 * - * def __eq__(self, Flag other not None): # <<<<<<<<<<<<<< - * return self._flag == other._flag + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag * */ -/* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_4Flag_1__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ -static PyObject *__pyx_pw_3ssh_9connector_4Flag_1__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_other), __pyx_ptype_3ssh_9connector_Flag, 0, "other", 0))) __PYX_ERR(1, 34, __pyx_L1_error) - __pyx_r = __pyx_pf_3ssh_9connector_4Flag___eq__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self), ((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_other)); +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self) { + double __pyx_r; - /* function exit code */ + /* "cpython/complex.pxd":24 + * @property + * cdef inline double imag(self) noexcept: + * return self.cval.imag # <<<<<<<<<<<<<< + * + * # PyTypeObject PyComplex_Type + */ + __pyx_r = __pyx_v_self->cval.imag; goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; + + /* "cpython/complex.pxd":23 + * + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag + * + */ + + /* function exit code */ __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_3ssh_9connector_4Flag___eq__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self, struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_other) { +/* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ + +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_RefNannySetupContext("get_value", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } + } - /* "ssh/connector.pyx":35 + /* "cpython/contextvars.pxd":117 + * or None if no such value or default was found. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: + */ + __pyx_v_value = NULL; + + /* "cpython/contextvars.pxd":118 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) # <<<<<<<<<<<<<< + * if value is NULL: + * # context variable does not have a default + */ + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, NULL, (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 118, __pyx_L1_error) + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + __pyx_t_2 = (__pyx_v_value == NULL); + if (__pyx_t_2) { + + /* "cpython/contextvars.pxd":121 + * if value is NULL: + * # context variable does not have a default + * pyvalue = default_value # <<<<<<<<<<<<<< + * else: + * # value or default value of context variable + */ + __Pyx_INCREF(__pyx_v_default_value); + __pyx_v_pyvalue = __pyx_v_default_value; + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + goto __pyx_L3; + } + + /* "cpython/contextvars.pxd":124 + * else: + * # value or default value of context variable + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + /*else*/ { + __pyx_t_3 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_pyvalue = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cpython/contextvars.pxd":125 + * # value or default value of context variable + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue + * + */ + Py_XDECREF(__pyx_v_value); + } + __pyx_L3:; + + /* "cpython/contextvars.pxd":126 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< * - * def __eq__(self, Flag other not None): - * return self._flag == other._flag # <<<<<<<<<<<<<< * - * def __str__(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_self->_flag == __pyx_v_other->_flag)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; goto __pyx_L0; - /* "ssh/connector.pyx":34 - * return _flag + /* "cpython/contextvars.pxd":112 * - * def __eq__(self, Flag other not None): # <<<<<<<<<<<<<< - * return self._flag == other._flag * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("ssh.connector.Flag.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("cpython.contextvars.get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "ssh/connector.pyx":37 - * return self._flag == other._flag +/* "cpython/contextvars.pxd":129 * - * def __str__(self): # <<<<<<<<<<<<<< - * return str(self._flag) * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. */ -/* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_4Flag_3__str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_3ssh_9connector_4Flag_3__str__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_9connector_4Flag_2__str__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_3ssh_9connector_4Flag_2__str__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self) { +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value_no_default(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_value_no_default", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } + } + + /* "cpython/contextvars.pxd":135 + * Ignores the default value of the context variable, if any. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + */ + __pyx_v_value = NULL; + + /* "cpython/contextvars.pxd":136 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, default_value, &value) # <<<<<<<<<<<<<< + * # value of context variable or 'default_value' + * pyvalue = value + */ + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, ((PyObject *)__pyx_v_default_value), (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 136, __pyx_L1_error) + + /* "cpython/contextvars.pxd":138 + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + __pyx_t_2 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_pyvalue = __pyx_t_2; + __pyx_t_2 = 0; + + /* "cpython/contextvars.pxd":139 + * # value of context variable or 'default_value' + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue + */ + Py_XDECREF(__pyx_v_value); + + /* "cpython/contextvars.pxd":140 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; + goto __pyx_L0; + + /* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("cpython.contextvars.get_value_no_default", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "ssh/connector.pyx":29 + * + * @staticmethod + * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): # <<<<<<<<<<<<<< + * cdef Flag _flag = Flag.__new__(Flag) + * _flag._flag = flag + */ + +static struct __pyx_obj_3ssh_9connector_Flag *__pyx_f_3ssh_9connector_4Flag_from_flag(enum ssh_connector_flags_e __pyx_v_flag) { + struct __pyx_obj_3ssh_9connector_Flag *__pyx_v__flag = 0; + struct __pyx_obj_3ssh_9connector_Flag *__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("from_flag", 1); + + /* "ssh/connector.pyx":30 + * @staticmethod + * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): + * cdef Flag _flag = Flag.__new__(Flag) # <<<<<<<<<<<<<< + * _flag._flag = flag + * return _flag + */ + __pyx_t_1 = ((PyObject *)__pyx_tp_new_3ssh_9connector_Flag(((PyTypeObject *)__pyx_ptype_3ssh_9connector_Flag), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 30, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + __pyx_v__flag = ((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "ssh/connector.pyx":31 + * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): + * cdef Flag _flag = Flag.__new__(Flag) + * _flag._flag = flag # <<<<<<<<<<<<<< + * return _flag + * + */ + __pyx_v__flag->_flag = __pyx_v_flag; + + /* "ssh/connector.pyx":32 + * cdef Flag _flag = Flag.__new__(Flag) + * _flag._flag = flag + * return _flag # <<<<<<<<<<<<<< + * + * def __eq__(self, Flag other not None): + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__flag); + __pyx_r = __pyx_v__flag; + goto __pyx_L0; + + /* "ssh/connector.pyx":29 + * + * @staticmethod + * cdef Flag from_flag(c_ssh.ssh_connector_flags_e flag): # <<<<<<<<<<<<<< + * cdef Flag _flag = Flag.__new__(Flag) + * _flag._flag = flag + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("ssh.connector.Flag.from_flag", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v__flag); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "ssh/connector.pyx":34 + * return _flag + * + * def __eq__(self, Flag other not None): # <<<<<<<<<<<<<< + * return self._flag == other._flag + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_3ssh_9connector_4Flag_1__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_3ssh_9connector_4Flag_1__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_other), __pyx_ptype_3ssh_9connector_Flag, 0, "other", 0))) __PYX_ERR(2, 34, __pyx_L1_error) + __pyx_r = __pyx_pf_3ssh_9connector_4Flag___eq__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self), ((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_other)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3ssh_9connector_4Flag___eq__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self, struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_other) { + 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("__eq__", 1); + + /* "ssh/connector.pyx":35 + * + * def __eq__(self, Flag other not None): + * return self._flag == other._flag # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_self->_flag == __pyx_v_other->_flag)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "ssh/connector.pyx":34 + * return _flag + * + * def __eq__(self, Flag other not None): # <<<<<<<<<<<<<< + * return self._flag == other._flag + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("ssh.connector.Flag.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "ssh/connector.pyx":37 + * return self._flag == other._flag + * + * def __str__(self): # <<<<<<<<<<<<<< + * return str(self._flag) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_3ssh_9connector_4Flag_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_3ssh_9connector_4Flag_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_3ssh_9connector_4Flag_2__str__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3ssh_9connector_4Flag_2__str__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; @@ -1849,7 +3715,7 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_2__str__(struct __pyx_obj_3ssh_9 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_RefNannySetupContext("__str__", 1); /* "ssh/connector.pyx":38 * @@ -1859,9 +3725,9 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_2__str__(struct __pyx_obj_3ssh_9 * def __repr__(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_enum__ssh_connector_flags_e(__pyx_v_self->_flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_enum__ssh_connector_flags_e(__pyx_v_self->_flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 38, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; @@ -1899,9 +3765,11 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_2__str__(struct __pyx_obj_3ssh_9 /* Python wrapper */ static PyObject *__pyx_pw_3ssh_9connector_4Flag_5__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_9connector_4Flag_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_3ssh_9connector_4Flag_4__repr__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self)); /* function exit code */ @@ -1915,10 +3783,11 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_4__repr__(struct __pyx_obj_3ssh_ PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_RefNannySetupContext("__repr__", 1); /* "ssh/connector.pyx":41 * @@ -1928,23 +3797,30 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_4__repr__(struct __pyx_obj_3ssh_ * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 41, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; } } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -1977,12 +3853,40 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_4__repr__(struct __pyx_obj_3ssh_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_4Flag_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_9connector_4Flag_6__reduce_cython__[] = "Flag.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_9connector_4Flag_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_9connector_4Flag_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_4Flag_6__reduce_cython__, "Flag.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_4Flag_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_4Flag_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_4Flag_6__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_9connector_4Flag_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self)); /* function exit code */ @@ -1999,12 +3903,11 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":5 * cdef object _dict @@ -2018,7 +3921,7 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error); __pyx_t_1 = 0; __pyx_v_state = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; @@ -2043,8 +3946,7 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ * use_setstate = True */ __pyx_t_3 = (__pyx_v__dict != Py_None); - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + if (__pyx_t_3) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -2057,7 +3959,7 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v__dict)) __PYX_ERR(0, 8, __pyx_L1_error); __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -2088,7 +3990,7 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ * else: * use_setstate = False # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, None), state + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, None), state */ /*else*/ { __pyx_v_use_setstate = 0; @@ -2099,18 +4001,17 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, None), state + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, None), state * else: */ - __pyx_t_4 = (__pyx_v_use_setstate != 0); - if (__pyx_t_4) { + if (__pyx_v_use_setstate) { /* "(tree fragment)":13 * use_setstate = False * if use_setstate: - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, state) + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pyx_unpickle_Flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) @@ -2119,66 +4020,66 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_233791475); - __Pyx_GIVEREF(__pyx_int_233791475); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_233791475); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_242378367); + __Pyx_GIVEREF(__pyx_int_242378367); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_242378367)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None)) __PYX_ERR(0, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(0, 13, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_2 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, None), state + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, None), state + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, None), state * else: - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Flag__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Flag); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Flag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_233791475); - __Pyx_GIVEREF(__pyx_int_233791475); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_233791475); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(0, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_242378367); + __Pyx_GIVEREF(__pyx_int_242378367); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_242378367)) __PYX_ERR(0, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state)) __PYX_ERR(0, 15, __pyx_L1_error); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); - __pyx_t_5 = 0; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error); + __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -2195,7 +4096,7 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("ssh.connector.Flag.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -2208,23 +4109,106 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_6__reduce_cython__(struct __pyx_ /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, state) + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Flag__set_state(self, __pyx_state) */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_4Flag_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_9connector_4Flag_8__setstate_cython__[] = "Flag.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_9connector_4Flag_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_9connector_4Flag_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_4Flag_8__setstate_cython__, "Flag.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_4Flag_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_4Flag_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_4Flag_8__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_9connector_4Flag_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_9connector_4Flag_8__setstate_cython__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.connector.Flag.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_9connector_4Flag_8__setstate_cython__(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; } static PyObject *__pyx_pf_3ssh_9connector_4Flag_8__setstate_cython__(struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_self, PyObject *__pyx_v___pyx_state) { @@ -2234,21 +4218,21 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_8__setstate_cython__(struct __py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":17 - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, state) + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Flag__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 17, __pyx_L1_error) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(0, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Flag, (type(self), 0xdef5ff3, state) + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Flag__set_state(self, __pyx_state) */ @@ -2278,49 +4262,69 @@ static PyObject *__pyx_pf_3ssh_9connector_4Flag_8__setstate_cython__(struct __py static int __pyx_pw_3ssh_9connector_9Connector_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_9connector_9Connector_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_3ssh_7session_Session *__pyx_v_session = 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("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 54, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 54, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(2, 54, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_session = ((struct __pyx_obj_3ssh_7session_Session *)values[0]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 54, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 54, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.connector.Connector.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_3ssh_7session_Session, 1, "session", 0))) __PYX_ERR(1, 54, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_3ssh_7session_Session, 1, "session", 0))) __PYX_ERR(2, 54, __pyx_L1_error) __pyx_r = __pyx_pf_3ssh_9connector_9Connector___cinit__(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), __pyx_v_session); /* function exit code */ @@ -2328,6 +4332,12 @@ static int __pyx_pw_3ssh_9connector_9Connector_1__cinit__(PyObject *__pyx_v_self __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2335,7 +4345,7 @@ static int __pyx_pw_3ssh_9connector_9Connector_1__cinit__(PyObject *__pyx_v_self static int __pyx_pf_3ssh_9connector_9Connector___cinit__(struct __pyx_obj_3ssh_9connector_Connector *__pyx_v_self, struct __pyx_obj_3ssh_7session_Session *__pyx_v_session) { int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_RefNannySetupContext("__cinit__", 1); /* "ssh/connector.pyx":55 * @@ -2344,10 +4354,10 @@ static int __pyx_pf_3ssh_9connector_9Connector___cinit__(struct __pyx_obj_3ssh_9 * * def __dealloc__(self): */ - __Pyx_INCREF(((PyObject *)__pyx_v_session)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_session)); - __Pyx_GOTREF(__pyx_v_self->session); - __Pyx_DECREF(((PyObject *)__pyx_v_self->session)); + __Pyx_INCREF((PyObject *)__pyx_v_session); + __Pyx_GIVEREF((PyObject *)__pyx_v_session); + __Pyx_GOTREF((PyObject *)__pyx_v_self->session); + __Pyx_DECREF((PyObject *)__pyx_v_self->session); __pyx_v_self->session = __pyx_v_session; /* "ssh/connector.pyx":54 @@ -2375,8 +4385,10 @@ static int __pyx_pf_3ssh_9connector_9Connector___cinit__(struct __pyx_obj_3ssh_9 /* Python wrapper */ static void __pyx_pw_3ssh_9connector_9Connector_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_3ssh_9connector_9Connector_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_3ssh_9connector_9Connector_2__dealloc__(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self)); /* function exit code */ @@ -2384,9 +4396,7 @@ static void __pyx_pw_3ssh_9connector_9Connector_3__dealloc__(PyObject *__pyx_v_s } static void __pyx_pf_3ssh_9connector_9Connector_2__dealloc__(struct __pyx_obj_3ssh_9connector_Connector *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "ssh/connector.pyx":58 * @@ -2395,7 +4405,7 @@ static void __pyx_pf_3ssh_9connector_9Connector_2__dealloc__(struct __pyx_obj_3s * c_ssh.ssh_connector_free(self._connector) * self._connector = NULL */ - __pyx_t_1 = ((__pyx_v_self->_connector != NULL) != 0); + __pyx_t_1 = (__pyx_v_self->_connector != NULL); if (__pyx_t_1) { /* "ssh/connector.pyx":59 @@ -2434,7 +4444,6 @@ static void __pyx_pf_3ssh_9connector_9Connector_2__dealloc__(struct __pyx_obj_3s */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "ssh/connector.pyx":63 @@ -2454,7 +4463,7 @@ static struct __pyx_obj_3ssh_9connector_Connector *__pyx_f_3ssh_9connector_9Conn int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("from_ptr", 0); + __Pyx_RefNannySetupContext("from_ptr", 1); /* "ssh/connector.pyx":64 * @staticmethod @@ -2463,13 +4472,13 @@ static struct __pyx_obj_3ssh_9connector_Connector *__pyx_f_3ssh_9connector_9Conn * connector._connector = _connector * return connector */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 64, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 64, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)__pyx_v_session)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_session)); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session)); - __pyx_t_2 = ((PyObject *)__pyx_tp_new_3ssh_9connector_Connector(((PyTypeObject *)__pyx_ptype_3ssh_9connector_Connector), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 64, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_2)); + __Pyx_INCREF((PyObject *)__pyx_v_session); + __Pyx_GIVEREF((PyObject *)__pyx_v_session); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(2, 64, __pyx_L1_error); + __pyx_t_2 = ((PyObject *)__pyx_tp_new_3ssh_9connector_Connector(((PyTypeObject *)__pyx_ptype_3ssh_9connector_Connector), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 64, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_connector = ((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_t_2); __pyx_t_2 = 0; @@ -2490,8 +4499,8 @@ static struct __pyx_obj_3ssh_9connector_Connector *__pyx_f_3ssh_9connector_9Conn * * def set_in_channel(self, Channel channel, Flag flag): */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v_connector)); + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_connector); __pyx_r = __pyx_v_connector; goto __pyx_L0; @@ -2525,65 +4534,106 @@ static struct __pyx_obj_3ssh_9connector_Connector *__pyx_f_3ssh_9connector_9Conn */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_9Connector_5set_in_channel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_9connector_9Connector_4set_in_channel[] = "Connector.set_in_channel(self, Channel channel, Flag flag)"; -static PyObject *__pyx_pw_3ssh_9connector_9Connector_5set_in_channel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_9connector_9Connector_5set_in_channel(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_9Connector_4set_in_channel, "Connector.set_in_channel(self, Channel channel, Flag flag)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_9Connector_5set_in_channel = {"set_in_channel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_5set_in_channel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_4set_in_channel}; +static PyObject *__pyx_pw_3ssh_9connector_9Connector_5set_in_channel(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 +) { struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_channel = 0; struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_flag = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_in_channel (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_channel,&__pyx_n_s_flag,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_channel,&__pyx_n_s_flag,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_channel)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_channel)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 68, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flag)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 68, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("set_in_channel", 1, 2, 2, 1); __PYX_ERR(1, 68, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_in_channel", 1, 2, 2, 1); __PYX_ERR(2, 68, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_in_channel") < 0)) __PYX_ERR(1, 68, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_in_channel") < 0)) __PYX_ERR(2, 68, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_channel = ((struct __pyx_obj_3ssh_7channel_Channel *)values[0]); __pyx_v_flag = ((struct __pyx_obj_3ssh_9connector_Flag *)values[1]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set_in_channel", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 68, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_in_channel", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 68, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.connector.Connector.set_in_channel", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_channel), __pyx_ptype_3ssh_7channel_Channel, 1, "channel", 0))) __PYX_ERR(1, 68, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flag), __pyx_ptype_3ssh_9connector_Flag, 1, "flag", 0))) __PYX_ERR(1, 68, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_channel), __pyx_ptype_3ssh_7channel_Channel, 1, "channel", 0))) __PYX_ERR(2, 68, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flag), __pyx_ptype_3ssh_9connector_Flag, 1, "flag", 0))) __PYX_ERR(2, 68, __pyx_L1_error) __pyx_r = __pyx_pf_3ssh_9connector_9Connector_4set_in_channel(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), __pyx_v_channel, __pyx_v_flag); /* function exit code */ @@ -2591,6 +4641,12 @@ static PyObject *__pyx_pw_3ssh_9connector_9Connector_5set_in_channel(PyObject *_ __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2604,7 +4660,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_4set_in_channel(struct __py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_in_channel", 0); + __Pyx_RefNannySetupContext("set_in_channel", 1); /* "ssh/connector.pyx":70 * def set_in_channel(self, Channel channel, Flag flag): @@ -2616,6 +4672,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_4set_in_channel(struct __py { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2658,8 +4715,8 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_4set_in_channel(struct __py * def set_out_channel(self, Channel channel, Flag flag): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_3ssh_5utils_handle_error_codes(__pyx_v_rc, __pyx_v_self->session->_session); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 73, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 73, __pyx_L1_error) + __pyx_t_1 = __pyx_f_3ssh_5utils_handle_error_codes(__pyx_v_rc, __pyx_v_self->session->_session); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 73, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; @@ -2693,65 +4750,106 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_4set_in_channel(struct __py */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_9Connector_7set_out_channel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_9connector_9Connector_6set_out_channel[] = "Connector.set_out_channel(self, Channel channel, Flag flag)"; -static PyObject *__pyx_pw_3ssh_9connector_9Connector_7set_out_channel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_9connector_9Connector_7set_out_channel(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_9Connector_6set_out_channel, "Connector.set_out_channel(self, Channel channel, Flag flag)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_9Connector_7set_out_channel = {"set_out_channel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_7set_out_channel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_6set_out_channel}; +static PyObject *__pyx_pw_3ssh_9connector_9Connector_7set_out_channel(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 +) { struct __pyx_obj_3ssh_7channel_Channel *__pyx_v_channel = 0; struct __pyx_obj_3ssh_9connector_Flag *__pyx_v_flag = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_out_channel (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_channel,&__pyx_n_s_flag,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_channel,&__pyx_n_s_flag,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_channel)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_channel)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 75, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flag)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 75, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("set_out_channel", 1, 2, 2, 1); __PYX_ERR(1, 75, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_out_channel", 1, 2, 2, 1); __PYX_ERR(2, 75, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_out_channel") < 0)) __PYX_ERR(1, 75, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_out_channel") < 0)) __PYX_ERR(2, 75, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_channel = ((struct __pyx_obj_3ssh_7channel_Channel *)values[0]); __pyx_v_flag = ((struct __pyx_obj_3ssh_9connector_Flag *)values[1]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set_out_channel", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 75, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set_out_channel", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 75, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.connector.Connector.set_out_channel", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_channel), __pyx_ptype_3ssh_7channel_Channel, 1, "channel", 0))) __PYX_ERR(1, 75, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flag), __pyx_ptype_3ssh_9connector_Flag, 1, "flag", 0))) __PYX_ERR(1, 75, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_channel), __pyx_ptype_3ssh_7channel_Channel, 1, "channel", 0))) __PYX_ERR(2, 75, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flag), __pyx_ptype_3ssh_9connector_Flag, 1, "flag", 0))) __PYX_ERR(2, 75, __pyx_L1_error) __pyx_r = __pyx_pf_3ssh_9connector_9Connector_6set_out_channel(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), __pyx_v_channel, __pyx_v_flag); /* function exit code */ @@ -2759,6 +4857,12 @@ static PyObject *__pyx_pw_3ssh_9connector_9Connector_7set_out_channel(PyObject * __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2772,7 +4876,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_6set_out_channel(struct __p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_out_channel", 0); + __Pyx_RefNannySetupContext("set_out_channel", 1); /* "ssh/connector.pyx":77 * def set_out_channel(self, Channel channel, Flag flag): @@ -2784,6 +4888,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_6set_out_channel(struct __p { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2826,8 +4931,8 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_6set_out_channel(struct __p * def set_in_fd(self, socket): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_3ssh_5utils_handle_error_codes(__pyx_v_rc, __pyx_v_self->session->_session); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 80, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 80, __pyx_L1_error) + __pyx_t_1 = __pyx_f_3ssh_5utils_handle_error_codes(__pyx_v_rc, __pyx_v_self->session->_session); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 80, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; @@ -2861,15 +4966,98 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_6set_out_channel(struct __p */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_9Connector_9set_in_fd(PyObject *__pyx_v_self, PyObject *__pyx_v_socket); /*proto*/ -static char __pyx_doc_3ssh_9connector_9Connector_8set_in_fd[] = "Connector.set_in_fd(self, socket)"; -static PyObject *__pyx_pw_3ssh_9connector_9Connector_9set_in_fd(PyObject *__pyx_v_self, PyObject *__pyx_v_socket) { +static PyObject *__pyx_pw_3ssh_9connector_9Connector_9set_in_fd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_9Connector_8set_in_fd, "Connector.set_in_fd(self, socket)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_9Connector_9set_in_fd = {"set_in_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_9set_in_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_8set_in_fd}; +static PyObject *__pyx_pw_3ssh_9connector_9Connector_9set_in_fd(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_socket = 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("set_in_fd (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_9connector_9Connector_8set_in_fd(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), ((PyObject *)__pyx_v_socket)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_socket,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_socket)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 82, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_in_fd") < 0)) __PYX_ERR(2, 82, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_socket = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_in_fd", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 82, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.connector.Connector.set_in_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_9connector_9Connector_8set_in_fd(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), __pyx_v_socket); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2882,7 +5070,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_8set_in_fd(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_in_fd", 0); + __Pyx_RefNannySetupContext("set_in_fd", 1); /* "ssh/connector.pyx":83 * @@ -2891,7 +5079,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_8set_in_fd(struct __pyx_obj * with nogil: * c_ssh.ssh_connector_set_in_fd(self._connector, _sock) */ - __pyx_t_1 = PyObject_AsFileDescriptor(__pyx_v_socket); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 83, __pyx_L1_error) + __pyx_t_1 = PyObject_AsFileDescriptor(__pyx_v_socket); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 83, __pyx_L1_error) __pyx_v__sock = __pyx_t_1; /* "ssh/connector.pyx":84 @@ -2904,6 +5092,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_8set_in_fd(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2967,15 +5156,98 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_8set_in_fd(struct __pyx_obj */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_9Connector_11set_out_fd(PyObject *__pyx_v_self, PyObject *__pyx_v_socket); /*proto*/ -static char __pyx_doc_3ssh_9connector_9Connector_10set_out_fd[] = "Connector.set_out_fd(self, socket)"; -static PyObject *__pyx_pw_3ssh_9connector_9Connector_11set_out_fd(PyObject *__pyx_v_self, PyObject *__pyx_v_socket) { +static PyObject *__pyx_pw_3ssh_9connector_9Connector_11set_out_fd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_9Connector_10set_out_fd, "Connector.set_out_fd(self, socket)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_9Connector_11set_out_fd = {"set_out_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_11set_out_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_10set_out_fd}; +static PyObject *__pyx_pw_3ssh_9connector_9Connector_11set_out_fd(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_socket = 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("set_out_fd (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_9connector_9Connector_10set_out_fd(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), ((PyObject *)__pyx_v_socket)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_socket,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_socket)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 87, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_out_fd") < 0)) __PYX_ERR(2, 87, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_socket = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_out_fd", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 87, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.connector.Connector.set_out_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_9connector_9Connector_10set_out_fd(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), __pyx_v_socket); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2988,7 +5260,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_10set_out_fd(struct __pyx_o int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_out_fd", 0); + __Pyx_RefNannySetupContext("set_out_fd", 1); /* "ssh/connector.pyx":88 * @@ -2997,7 +5269,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_10set_out_fd(struct __pyx_o * with nogil: * c_ssh.ssh_connector_set_out_fd(self._connector, _sock) */ - __pyx_t_1 = PyObject_AsFileDescriptor(__pyx_v_socket); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 88, __pyx_L1_error) + __pyx_t_1 = PyObject_AsFileDescriptor(__pyx_v_socket); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 88, __pyx_L1_error) __pyx_v__sock = __pyx_t_1; /* "ssh/connector.pyx":89 @@ -3009,6 +5281,7 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_10set_out_fd(struct __pyx_o { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3071,9 +5344,11 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_10set_out_fd(struct __pyx_o /* Python wrapper */ static PyObject *__pyx_pw_3ssh_9connector_9Connector_7session_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_9connector_9Connector_7session_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_3ssh_9connector_9Connector_7session___get__(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self)); /* function exit code */ @@ -3084,9 +5359,9 @@ static PyObject *__pyx_pw_3ssh_9connector_9Connector_7session_1__get__(PyObject static PyObject *__pyx_pf_3ssh_9connector_9Connector_7session___get__(struct __pyx_obj_3ssh_9connector_Connector *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self->session)); + __Pyx_INCREF((PyObject *)__pyx_v_self->session); __pyx_r = ((PyObject *)__pyx_v_self->session); goto __pyx_L0; @@ -3099,17 +5374,45 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_7session___get__(struct __p /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_9connector_9Connector_12__reduce_cython__[] = "Connector.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_9Connector_12__reduce_cython__, "Connector.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_9Connector_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_12__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_9connector_9Connector_12__reduce_cython__(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self)); /* function exit code */ @@ -3120,33 +5423,28 @@ static PyObject *__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__(PyObjec static PyObject *__pyx_pf_3ssh_9connector_9Connector_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_9connector_Connector *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.connector.Connector.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3156,21 +5454,104 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_12__reduce_cython__(CYTHON_ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_9connector_9Connector_14__setstate_cython__[] = "Connector.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector_9Connector_14__setstate_cython__, "Connector.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_9Connector_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_14__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_9connector_9Connector_14__setstate_cython__(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.connector.Connector.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_9connector_9Connector_14__setstate_cython__(((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3178,33 +5559,28 @@ static PyObject *__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__(PyObj static PyObject *__pyx_pf_3ssh_9connector_9Connector_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_9connector_Connector *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.connector.Connector.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3219,71 +5595,115 @@ static PyObject *__pyx_pf_3ssh_9connector_9Connector_14__setstate_cython__(CYTHO */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_9connector_1__pyx_unpickle_Flag(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_9connector___pyx_unpickle_Flag[] = "__pyx_unpickle_Flag(__pyx_type, long __pyx_checksum, __pyx_state)"; -static PyMethodDef __pyx_mdef_3ssh_9connector_1__pyx_unpickle_Flag = {"__pyx_unpickle_Flag", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_9connector_1__pyx_unpickle_Flag, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_9connector___pyx_unpickle_Flag}; -static PyObject *__pyx_pw_3ssh_9connector_1__pyx_unpickle_Flag(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_9connector_1__pyx_unpickle_Flag(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_9connector___pyx_unpickle_Flag, "__pyx_unpickle_Flag(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_9connector_1__pyx_unpickle_Flag = {"__pyx_unpickle_Flag", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_1__pyx_unpickle_Flag, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector___pyx_unpickle_Flag}; +static PyObject *__pyx_pw_3ssh_9connector_1__pyx_unpickle_Flag(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_Flag (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Flag", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Flag", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Flag") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Flag") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Flag", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Flag", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.connector.__pyx_unpickle_Flag", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3291,6 +5711,12 @@ static PyObject *__pyx_pw_3ssh_9connector_1__pyx_unpickle_Flag(PyObject *__pyx_s __pyx_r = __pyx_pf_3ssh_9connector___pyx_unpickle_Flag(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3302,129 +5728,116 @@ static PyObject *__pyx_pf_3ssh_9connector___pyx_unpickle_Flag(CYTHON_UNUSED PyOb __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; + int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Flag", 0); + __Pyx_RefNannySetupContext("__pyx_unpickle_Flag", 1); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum not in (0xdef5ff3, 0xe72667f, 0x5913c31): # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0xe72667f, 0x5913c31, 0xdef5ff3): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__3, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple_, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { /* "(tree fragment)":5 * cdef object __pyx_result - * if __pyx_checksum not in (0xdef5ff3, 0xe72667f, 0x5913c31): + * if __pyx_checksum not in (0xe72667f, 0x5913c31, 0xdef5ff3): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum * __pyx_result = Flag.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); - __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 - * if __pyx_checksum not in (0xdef5ff3, 0xe72667f, 0x5913c31): + * if __pyx_checksum not in (0xe72667f, 0x5913c31, 0xdef5ff3): * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))" % __pyx_checksum) # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum # <<<<<<<<<<<<<< * __pyx_result = Flag.__new__(__pyx_type) * if __pyx_state is not None: */ - __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum not in (0xdef5ff3, 0xe72667f, 0x5913c31): # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0xe72667f, 0x5913c31, 0xdef5ff3): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum * __pyx_result = Flag.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_Flag__set_state( __pyx_result, __pyx_state) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_3ssh_9connector_Flag), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_3ssh_9connector_Flag), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result = __pyx_t_4; - __pyx_t_4 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum * __pyx_result = Flag.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Flag__set_state( __pyx_result, __pyx_state) * return __pyx_result */ - __pyx_t_3 = (__pyx_v___pyx_state != Py_None); - __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); if (__pyx_t_2) { /* "(tree fragment)":9 @@ -3434,13 +5847,13 @@ static PyObject *__pyx_pf_3ssh_9connector___pyx_unpickle_Flag(CYTHON_UNUSED PyOb * return __pyx_result * cdef __pyx_unpickle_Flag__set_state(Flag __pyx_result, tuple __pyx_state): */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 9, __pyx_L1_error) - __pyx_t_4 = __pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(((struct __pyx_obj_3ssh_9connector_Flag *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xdef5ff3, 0xe72667f, 0x5913c31) = (_flag))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum * __pyx_result = Flag.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Flag__set_state( __pyx_result, __pyx_state) @@ -3469,9 +5882,8 @@ static PyObject *__pyx_pf_3ssh_9connector___pyx_unpickle_Flag(CYTHON_UNUSED PyOb /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("ssh.connector.__pyx_unpickle_Flag", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -3497,14 +5909,14 @@ static PyObject *__pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(struct _ int __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; + int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Flag__set_state", 0); + __Pyx_RefNannySetupContext("__pyx_unpickle_Flag__set_state", 1); /* "(tree fragment)":12 * return __pyx_result @@ -3530,16 +5942,15 @@ static PyObject *__pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(struct _ PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 13, __pyx_L1_error) } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 1) != 0); + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 13, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; + __pyx_t_2 = __pyx_t_4; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { @@ -3548,31 +5959,38 @@ static PyObject *__pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(struct _ * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 14, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 14, __pyx_L1_error) } - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); + __pyx_t_6 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_8 = 1; } } - __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, PyTuple_GET_ITEM(__pyx_v___pyx_state, 1)) : __Pyx_PyObject_CallOneArg(__pyx_t_8, PyTuple_GET_ITEM(__pyx_v___pyx_state, 1)); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, PyTuple_GET_ITEM(__pyx_v___pyx_state, 1)}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_Flag__set_state(Flag __pyx_result, tuple __pyx_state): @@ -3594,9 +6012,9 @@ static PyObject *__pyx_f_3ssh_9connector___pyx_unpickle_Flag__set_state(struct _ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("ssh.connector.__pyx_unpickle_Flag__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -3609,12 +6027,17 @@ static struct __pyx_vtabstruct_3ssh_9connector_Flag __pyx_vtable_3ssh_9connector static PyObject *__pyx_tp_new_3ssh_9connector_Flag(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_3ssh_9connector_Flag *p; PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif p = ((struct __pyx_obj_3ssh_9connector_Flag *)o); p->__pyx_vtab = __pyx_vtabptr_3ssh_9connector_Flag; return o; @@ -3622,11 +6045,20 @@ static PyObject *__pyx_tp_new_3ssh_9connector_Flag(PyTypeObject *t, CYTHON_UNUSE static void __pyx_tp_dealloc_3ssh_9connector_Flag(PyObject *o) { #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { - if (PyObject_CallFinalizerFromDealloc(o)) return; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_3ssh_9connector_Flag) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyObject *__pyx_tp_richcompare_3ssh_9connector_Flag(PyObject *o1, PyObject *o2, int op) { @@ -3638,7 +6070,8 @@ static PyObject *__pyx_tp_richcompare_3ssh_9connector_Flag(PyObject *o1, PyObjec PyObject *ret; ret = __pyx_pw_3ssh_9connector_4Flag_1__eq__(o1, o2); if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); if (unlikely(b < 0)) return NULL; ret = (b) ? Py_False : Py_True; Py_INCREF(ret); @@ -3651,15 +6084,38 @@ static PyObject *__pyx_tp_richcompare_3ssh_9connector_Flag(PyObject *o1, PyObjec } } +static PyObject *__pyx_specialmethod___pyx_pw_3ssh_9connector_4Flag_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_3ssh_9connector_4Flag_5__repr__(self); +} + static PyMethodDef __pyx_methods_3ssh_9connector_Flag[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_9connector_4Flag_7__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_9connector_4Flag_6__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_9connector_4Flag_9__setstate_cython__, METH_O, __pyx_doc_3ssh_9connector_4Flag_8__setstate_cython__}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_3ssh_9connector_4Flag_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_4Flag_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_4Flag_6__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_4Flag_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_4Flag_8__setstate_cython__}, {0, 0, 0, 0} }; - -static PyTypeObject __pyx_type_3ssh_9connector_Flag = { +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_9connector_Flag_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_3ssh_9connector_Flag}, + {Py_tp_repr, (void *)__pyx_pw_3ssh_9connector_4Flag_5__repr__}, + {Py_tp_str, (void *)__pyx_pw_3ssh_9connector_4Flag_3__str__}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_3ssh_9connector_Flag}, + {Py_tp_methods, (void *)__pyx_methods_3ssh_9connector_Flag}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_9connector_Flag}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_9connector_Flag_spec = { + "ssh.connector.Flag", + sizeof(struct __pyx_obj_3ssh_9connector_Flag), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_9connector_Flag_slots, +}; +#else + +static PyTypeObject __pyx_type_3ssh_9connector_Flag = { PyVarObject_HEAD_INIT(0, 0) - "ssh.connector.Flag", /*tp_name*/ + "ssh.connector.""Flag", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_9connector_Flag), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_9connector_Flag, /*tp_dealloc*/ @@ -3702,7 +6158,9 @@ static PyTypeObject __pyx_type_3ssh_9connector_Flag = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_9connector_Flag, /*tp_new*/ @@ -3716,29 +6174,42 @@ static PyTypeObject __pyx_type_3ssh_9connector_Flag = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static struct __pyx_vtabstruct_3ssh_9connector_Connector __pyx_vtable_3ssh_9connector_Connector; static PyObject *__pyx_tp_new_3ssh_9connector_Connector(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_3ssh_9connector_Connector *p; PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif p = ((struct __pyx_obj_3ssh_9connector_Connector *)o); p->__pyx_vtab = __pyx_vtabptr_3ssh_9connector_Connector; p->session = ((struct __pyx_obj_3ssh_7session_Session *)Py_None); Py_INCREF(Py_None); @@ -3752,8 +6223,10 @@ static PyObject *__pyx_tp_new_3ssh_9connector_Connector(PyTypeObject *t, PyObjec static void __pyx_tp_dealloc_3ssh_9connector_Connector(PyObject *o) { struct __pyx_obj_3ssh_9connector_Connector *p = (struct __pyx_obj_3ssh_9connector_Connector *)o; #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { - if (PyObject_CallFinalizerFromDealloc(o)) return; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_3ssh_9connector_Connector) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif PyObject_GC_UnTrack(o); @@ -3766,7 +6239,14 @@ static void __pyx_tp_dealloc_3ssh_9connector_Connector(PyObject *o) { PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->session); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static int __pyx_tp_traverse_3ssh_9connector_Connector(PyObject *o, visitproc v, void *a) { @@ -3792,12 +6272,12 @@ static PyObject *__pyx_getprop_3ssh_9connector_9Connector_session(PyObject *o, C } static PyMethodDef __pyx_methods_3ssh_9connector_Connector[] = { - {"set_in_channel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_9connector_9Connector_5set_in_channel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_4set_in_channel}, - {"set_out_channel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_9connector_9Connector_7set_out_channel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_6set_out_channel}, - {"set_in_fd", (PyCFunction)__pyx_pw_3ssh_9connector_9Connector_9set_in_fd, METH_O, __pyx_doc_3ssh_9connector_9Connector_8set_in_fd}, - {"set_out_fd", (PyCFunction)__pyx_pw_3ssh_9connector_9Connector_11set_out_fd, METH_O, __pyx_doc_3ssh_9connector_9Connector_10set_out_fd}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_9connector_9Connector_12__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__, METH_O, __pyx_doc_3ssh_9connector_9Connector_14__setstate_cython__}, + {"set_in_channel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_5set_in_channel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_4set_in_channel}, + {"set_out_channel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_7set_out_channel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_6set_out_channel}, + {"set_in_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_9set_in_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_8set_in_fd}, + {"set_out_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_11set_out_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_10set_out_fd}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_9connector_9Connector_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_9connector_9Connector_14__setstate_cython__}, {0, 0, 0, 0} }; @@ -3805,10 +6285,28 @@ static struct PyGetSetDef __pyx_getsets_3ssh_9connector_Connector[] = { {(char *)"session", __pyx_getprop_3ssh_9connector_9Connector_session, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_9connector_Connector_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_3ssh_9connector_Connector}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_3ssh_9connector_Connector}, + {Py_tp_clear, (void *)__pyx_tp_clear_3ssh_9connector_Connector}, + {Py_tp_methods, (void *)__pyx_methods_3ssh_9connector_Connector}, + {Py_tp_getset, (void *)__pyx_getsets_3ssh_9connector_Connector}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_9connector_Connector}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_9connector_Connector_spec = { + "ssh.connector.Connector", + sizeof(struct __pyx_obj_3ssh_9connector_Connector), + 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_3ssh_9connector_Connector_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_9connector_Connector = { PyVarObject_HEAD_INIT(0, 0) - "ssh.connector.Connector", /*tp_name*/ + "ssh.connector.""Connector", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_9connector_Connector), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_9connector_Connector, /*tp_dealloc*/ @@ -3851,7 +6349,9 @@ static PyTypeObject __pyx_type_3ssh_9connector_Connector = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_9connector_Connector, /*tp_new*/ @@ -3865,54 +6365,30 @@ static PyTypeObject __pyx_type_3ssh_9connector_Connector = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_connector(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_connector}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "connector", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -3922,105 +6398,216 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_CONNECTOR_BOTH, __pyx_k_CONNECTOR_BOTH, sizeof(__pyx_k_CONNECTOR_BOTH), 0, 0, 1, 1}, - {&__pyx_n_s_CONNECTOR_STDERR, __pyx_k_CONNECTOR_STDERR, sizeof(__pyx_k_CONNECTOR_STDERR), 0, 0, 1, 1}, - {&__pyx_n_s_CONNECTOR_STDOUT, __pyx_k_CONNECTOR_STDOUT, sizeof(__pyx_k_CONNECTOR_STDOUT), 0, 0, 1, 1}, - {&__pyx_n_s_Connector, __pyx_k_Connector, sizeof(__pyx_k_Connector), 0, 0, 1, 1}, - {&__pyx_n_s_Flag, __pyx_k_Flag, sizeof(__pyx_k_Flag), 0, 0, 1, 1}, - {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, - {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_channel, __pyx_k_channel, sizeof(__pyx_k_channel), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_n_s_flag, __pyx_k_flag, sizeof(__pyx_k_flag), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_Flag, __pyx_k_pyx_unpickle_Flag, sizeof(__pyx_k_pyx_unpickle_Flag), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_ssh_connector, __pyx_k_ssh_connector, sizeof(__pyx_k_ssh_connector), 0, 0, 1, 1}, - {&__pyx_n_s_str, __pyx_k_str, sizeof(__pyx_k_str), 0, 0, 1, 1}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_CONNECTOR_BOTH, __pyx_k_CONNECTOR_BOTH, sizeof(__pyx_k_CONNECTOR_BOTH), 0, 0, 1, 1}, + {&__pyx_n_s_CONNECTOR_STDERR, __pyx_k_CONNECTOR_STDERR, sizeof(__pyx_k_CONNECTOR_STDERR), 0, 0, 1, 1}, + {&__pyx_n_s_CONNECTOR_STDOUT, __pyx_k_CONNECTOR_STDOUT, sizeof(__pyx_k_CONNECTOR_STDOUT), 0, 0, 1, 1}, + {&__pyx_n_s_Connector, __pyx_k_Connector, sizeof(__pyx_k_Connector), 0, 0, 1, 1}, + {&__pyx_n_s_Connector___reduce_cython, __pyx_k_Connector___reduce_cython, sizeof(__pyx_k_Connector___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Connector___setstate_cython, __pyx_k_Connector___setstate_cython, sizeof(__pyx_k_Connector___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Connector_set_in_channel, __pyx_k_Connector_set_in_channel, sizeof(__pyx_k_Connector_set_in_channel), 0, 0, 1, 1}, + {&__pyx_n_s_Connector_set_in_fd, __pyx_k_Connector_set_in_fd, sizeof(__pyx_k_Connector_set_in_fd), 0, 0, 1, 1}, + {&__pyx_n_s_Connector_set_out_channel, __pyx_k_Connector_set_out_channel, sizeof(__pyx_k_Connector_set_out_channel), 0, 0, 1, 1}, + {&__pyx_n_s_Connector_set_out_fd, __pyx_k_Connector_set_out_fd, sizeof(__pyx_k_Connector_set_out_fd), 0, 0, 1, 1}, + {&__pyx_n_s_Flag, __pyx_k_Flag, sizeof(__pyx_k_Flag), 0, 0, 1, 1}, + {&__pyx_n_s_Flag___reduce_cython, __pyx_k_Flag___reduce_cython, sizeof(__pyx_k_Flag___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Flag___setstate_cython, __pyx_k_Flag___setstate_cython, sizeof(__pyx_k_Flag___setstate_cython), 0, 0, 1, 1}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 0, 1, 1}, + {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_channel, __pyx_k_channel, sizeof(__pyx_k_channel), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dict_2, __pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_flag, __pyx_k_flag, sizeof(__pyx_k_flag), 0, 0, 1, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Flag, __pyx_k_pyx_unpickle_Flag, sizeof(__pyx_k_pyx_unpickle_Flag), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1}, + {&__pyx_n_s_set_in_channel, __pyx_k_set_in_channel, sizeof(__pyx_k_set_in_channel), 0, 0, 1, 1}, + {&__pyx_n_s_set_in_fd, __pyx_k_set_in_fd, sizeof(__pyx_k_set_in_fd), 0, 0, 1, 1}, + {&__pyx_n_s_set_out_channel, __pyx_k_set_out_channel, sizeof(__pyx_k_set_out_channel), 0, 0, 1, 1}, + {&__pyx_n_s_set_out_fd, __pyx_k_set_out_fd, sizeof(__pyx_k_set_out_fd), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_sock, __pyx_k_sock, sizeof(__pyx_k_sock), 0, 0, 1, 1}, + {&__pyx_n_s_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 0, 1, 1}, + {&__pyx_n_s_ssh_connector, __pyx_k_ssh_connector, sizeof(__pyx_k_ssh_connector), 0, 0, 1, 1}, + {&__pyx_kp_s_ssh_connector_pyx, __pyx_k_ssh_connector_pyx, sizeof(__pyx_k_ssh_connector_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, + {&__pyx_n_s_str, __pyx_k_str, sizeof(__pyx_k_str), 0, 0, 1, 1}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe72667f, 0x5913c31, 0xdef5ff3): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe72667f, 0x5913c31, 0xdef5ff3) = (_flag))" % __pyx_checksum */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(3, __pyx_int_242378367, __pyx_int_93404209, __pyx_int_233791475); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - /* "(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__") # <<<<<<<<<<<<<< + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - __pyx_tuple__3 = PyTuple_Pack(3, __pyx_int_233791475, __pyx_int_242378367, __pyx_int_93404209); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 4, __pyx_L1_error) + __pyx_tuple__3 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_state, __pyx_n_s_dict_2, __pyx_n_s_use_setstate); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Flag__set_state(self, __pyx_state) + */ + __pyx_tuple__5 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 16, __pyx_L1_error) + + /* "ssh/connector.pyx":68 + * return connector + * + * def set_in_channel(self, Channel channel, Flag flag): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__7 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_channel, __pyx_n_s_flag, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_connector_pyx, __pyx_n_s_set_in_channel, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(2, 68, __pyx_L1_error) + + /* "ssh/connector.pyx":75 + * return handle_error_codes(rc, self.session._session) + * + * def set_out_channel(self, Channel channel, Flag flag): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_connector_pyx, __pyx_n_s_set_out_channel, 75, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(2, 75, __pyx_L1_error) + + /* "ssh/connector.pyx":82 + * return handle_error_codes(rc, self.session._session) + * + * def set_in_fd(self, socket): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(socket) + * with nogil: + */ + __pyx_tuple__10 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_socket, __pyx_n_s_sock); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_connector_pyx, __pyx_n_s_set_in_fd, 82, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(2, 82, __pyx_L1_error) + + /* "ssh/connector.pyx":87 + * c_ssh.ssh_connector_set_in_fd(self._connector, _sock) + * + * def set_out_fd(self, socket): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(socket) + * with nogil: + */ + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_connector_pyx, __pyx_n_s_set_out_fd, 87, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(2, 87, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 3, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_Flag(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ - __pyx_tuple__4 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Flag, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_tuple__16 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Flag, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } +/* #### Code section: init_constants ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error); - __pyx_int_93404209 = PyInt_FromLong(93404209L); if (unlikely(!__pyx_int_93404209)) __PYX_ERR(1, 1, __pyx_L1_error) - __pyx_int_233791475 = PyInt_FromLong(233791475L); if (unlikely(!__pyx_int_233791475)) __PYX_ERR(1, 1, __pyx_L1_error) - __pyx_int_242378367 = PyInt_FromLong(242378367L); if (unlikely(!__pyx_int_242378367)) __PYX_ERR(1, 1, __pyx_L1_error) +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(2, 1, __pyx_L1_error); + __pyx_int_93404209 = PyInt_FromLong(93404209L); if (unlikely(!__pyx_int_93404209)) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_int_233791475 = PyInt_FromLong(233791475L); if (unlikely(!__pyx_int_233791475)) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_int_242378367 = PyInt_FromLong(242378367L); if (unlikely(!__pyx_int_242378367)) __PYX_ERR(2, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -4063,30 +6650,62 @@ static int __Pyx_modinit_type_init_code(void) { /*--- Type init code ---*/ __pyx_vtabptr_3ssh_9connector_Flag = &__pyx_vtable_3ssh_9connector_Flag; __pyx_vtable_3ssh_9connector_Flag.from_flag = (struct __pyx_obj_3ssh_9connector_Flag *(*)(enum ssh_connector_flags_e))__pyx_f_3ssh_9connector_4Flag_from_flag; - if (PyType_Ready(&__pyx_type_3ssh_9connector_Flag) < 0) __PYX_ERR(1, 26, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_9connector_Flag.tp_print = 0; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_3ssh_9connector_Flag = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_9connector_Flag_spec, NULL); if (unlikely(!__pyx_ptype_3ssh_9connector_Flag)) __PYX_ERR(2, 26, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_9connector_Flag_spec, __pyx_ptype_3ssh_9connector_Flag) < 0) __PYX_ERR(2, 26, __pyx_L1_error) + #else + __pyx_ptype_3ssh_9connector_Flag = &__pyx_type_3ssh_9connector_Flag; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_9connector_Flag) < 0) __PYX_ERR(2, 26, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_9connector_Flag->tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_9connector_Flag.tp_dictoffset && __pyx_type_3ssh_9connector_Flag.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_9connector_Flag.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_9connector_Flag->tp_dictoffset && __pyx_ptype_3ssh_9connector_Flag->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_9connector_Flag->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_3ssh_9connector_Flag.tp_dict, __pyx_vtabptr_3ssh_9connector_Flag) < 0) __PYX_ERR(1, 26, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Flag, (PyObject *)&__pyx_type_3ssh_9connector_Flag) < 0) __PYX_ERR(1, 26, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_9connector_Flag) < 0) __PYX_ERR(1, 26, __pyx_L1_error) - __pyx_ptype_3ssh_9connector_Flag = &__pyx_type_3ssh_9connector_Flag; + #endif + if (__Pyx_SetVtable(__pyx_ptype_3ssh_9connector_Flag, __pyx_vtabptr_3ssh_9connector_Flag) < 0) __PYX_ERR(2, 26, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_3ssh_9connector_Flag) < 0) __PYX_ERR(2, 26, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Flag, (PyObject *) __pyx_ptype_3ssh_9connector_Flag) < 0) __PYX_ERR(2, 26, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_9connector_Flag) < 0) __PYX_ERR(2, 26, __pyx_L1_error) + #endif __pyx_vtabptr_3ssh_9connector_Connector = &__pyx_vtable_3ssh_9connector_Connector; __pyx_vtable_3ssh_9connector_Connector.from_ptr = (struct __pyx_obj_3ssh_9connector_Connector *(*)(ssh_connector, struct __pyx_obj_3ssh_7session_Session *))__pyx_f_3ssh_9connector_9Connector_from_ptr; - if (PyType_Ready(&__pyx_type_3ssh_9connector_Connector) < 0) __PYX_ERR(1, 52, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_9connector_Connector.tp_print = 0; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_3ssh_9connector_Connector = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_9connector_Connector_spec, NULL); if (unlikely(!__pyx_ptype_3ssh_9connector_Connector)) __PYX_ERR(2, 52, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_9connector_Connector_spec, __pyx_ptype_3ssh_9connector_Connector) < 0) __PYX_ERR(2, 52, __pyx_L1_error) + #else + __pyx_ptype_3ssh_9connector_Connector = &__pyx_type_3ssh_9connector_Connector; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_9connector_Connector.tp_dictoffset && __pyx_type_3ssh_9connector_Connector.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_9connector_Connector.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_9connector_Connector) < 0) __PYX_ERR(2, 52, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_9connector_Connector->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_9connector_Connector->tp_dictoffset && __pyx_ptype_3ssh_9connector_Connector->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_9connector_Connector->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_3ssh_9connector_Connector.tp_dict, __pyx_vtabptr_3ssh_9connector_Connector) < 0) __PYX_ERR(1, 52, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Connector, (PyObject *)&__pyx_type_3ssh_9connector_Connector) < 0) __PYX_ERR(1, 52, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_9connector_Connector) < 0) __PYX_ERR(1, 52, __pyx_L1_error) - __pyx_ptype_3ssh_9connector_Connector = &__pyx_type_3ssh_9connector_Connector; + #endif + if (__Pyx_SetVtable(__pyx_ptype_3ssh_9connector_Connector, __pyx_vtabptr_3ssh_9connector_Connector) < 0) __PYX_ERR(2, 52, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_3ssh_9connector_Connector) < 0) __PYX_ERR(2, 52, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Connector, (PyObject *) __pyx_ptype_3ssh_9connector_Connector) < 0) __PYX_ERR(2, 52, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_9connector_Connector) < 0) __PYX_ERR(2, 52, __pyx_L1_error) + #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -4102,37 +6721,34 @@ static int __Pyx_modinit_type_import_code(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule("ssh.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("ssh.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error) + __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(3, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), #else - sizeof(PyHeapTypeObject), + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(4, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 8, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(4, 8, __pyx_L1_error) + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyBoolObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(5, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 15, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(5, 15, __pyx_L1_error) + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyComplexObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(6, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("ssh.channel"); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 22, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("ssh.channel"); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_3ssh_7channel_Channel = __Pyx_ImportType(__pyx_t_1, "ssh.channel", "Channel", sizeof(struct __pyx_obj_3ssh_7channel_Channel), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_7channel_Channel) __PYX_ERR(6, 22, __pyx_L1_error) - __pyx_vtabptr_3ssh_7channel_Channel = (struct __pyx_vtabstruct_3ssh_7channel_Channel*)__Pyx_GetVtable(__pyx_ptype_3ssh_7channel_Channel->tp_dict); if (unlikely(!__pyx_vtabptr_3ssh_7channel_Channel)) __PYX_ERR(6, 22, __pyx_L1_error) + __pyx_ptype_3ssh_7channel_Channel = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.channel", "Channel", sizeof(struct __pyx_obj_3ssh_7channel_Channel), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_7channel_Channel),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_7channel_Channel) __PYX_ERR(7, 22, __pyx_L1_error) + __pyx_vtabptr_3ssh_7channel_Channel = (struct __pyx_vtabstruct_3ssh_7channel_Channel*)__Pyx_GetVtable(__pyx_ptype_3ssh_7channel_Channel); if (unlikely(!__pyx_vtabptr_3ssh_7channel_Channel)) __PYX_ERR(7, 22, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -4158,9 +6774,9 @@ static int __Pyx_modinit_function_import_code(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ - __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -4171,6 +6787,55 @@ static int __Pyx_modinit_function_import_code(void) { } +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_connector(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_connector}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "connector", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 @@ -4221,12 +6886,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -4236,8 +6910,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -4247,8 +6922,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -4264,7 +6943,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_connector(PyObject *__pyx_pyinit_m #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -4278,6 +6962,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_connector(PyObject *__pyx_pyinit_m #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("connector", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(2, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "connector" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(2, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(2, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(2, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(2, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -4288,88 +6999,94 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_connector(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(1, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(2, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("connector", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_InitConstants() < 0) __PYX_ERR(2, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(2, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_ssh__connector) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(2, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error) + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(2, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "ssh.connector")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.connector", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "ssh.connector", __pyx_m) < 0))) __PYX_ERR(2, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(2, 1, __pyx_L1_error) /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(2, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error) - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(2, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(2, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(2, 1, __pyx_L1_error) /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_patch_abc() < 0) __PYX_ERR(2, 1, __pyx_L1_error) #endif + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_4Flag_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Flag___reduce_cython, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9connector_Flag, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9connector_Flag); + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Flag, (type(self), 0xe72667f, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Flag__set_state(self, __pyx_state) + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_4Flag_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Flag___setstate_cython, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9connector_Flag, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9connector_Flag); + /* "ssh/connector.pyx":44 * * @@ -4377,10 +7094,10 @@ if (!__Pyx_RefNanny) { * c_ssh.ssh_connector_flags_e.SSH_CONNECTOR_STDOUT) * CONNECTOR_STDERR = Flag.from_flag( */ - __pyx_t_1 = ((PyObject *)__pyx_f_3ssh_9connector_4Flag_from_flag(SSH_CONNECTOR_STDOUT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CONNECTOR_STDOUT, __pyx_t_1) < 0) __PYX_ERR(1, 44, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = ((PyObject *)__pyx_f_3ssh_9connector_4Flag_from_flag(SSH_CONNECTOR_STDOUT)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CONNECTOR_STDOUT, __pyx_t_2) < 0) __PYX_ERR(2, 44, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "ssh/connector.pyx":46 * CONNECTOR_STDOUT = Flag.from_flag( @@ -4389,10 +7106,10 @@ if (!__Pyx_RefNanny) { * c_ssh.ssh_connector_flags_e.SSH_CONNECTOR_STDERR) * CONNECTOR_BOTH = Flag.from_flag( */ - __pyx_t_1 = ((PyObject *)__pyx_f_3ssh_9connector_4Flag_from_flag(SSH_CONNECTOR_STDERR)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CONNECTOR_STDERR, __pyx_t_1) < 0) __PYX_ERR(1, 46, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = ((PyObject *)__pyx_f_3ssh_9connector_4Flag_from_flag(SSH_CONNECTOR_STDERR)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CONNECTOR_STDERR, __pyx_t_2) < 0) __PYX_ERR(2, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "ssh/connector.pyx":48 * CONNECTOR_STDERR = Flag.from_flag( @@ -4401,41 +7118,124 @@ if (!__Pyx_RefNanny) { * c_ssh.ssh_connector_flags_e.SSH_CONNECTOR_BOTH) * */ - __pyx_t_1 = ((PyObject *)__pyx_f_3ssh_9connector_4Flag_from_flag(SSH_CONNECTOR_BOTH)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CONNECTOR_BOTH, __pyx_t_1) < 0) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = ((PyObject *)__pyx_f_3ssh_9connector_4Flag_from_flag(SSH_CONNECTOR_BOTH)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CONNECTOR_BOTH, __pyx_t_2) < 0) __PYX_ERR(2, 48, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "(tree fragment)":1 - * def __pyx_unpickle_Flag(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + /* "ssh/connector.pyx":68 + * return connector + * + * def set_in_channel(self, Channel channel, Flag flag): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_3ssh_9connector_1__pyx_unpickle_Flag, NULL, __pyx_n_s_ssh_connector); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Flag, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_9Connector_5set_in_channel, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Connector_set_in_channel, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9connector_Connector, __pyx_n_s_set_in_channel, __pyx_t_2) < 0) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9connector_Connector); - /* "ssh/connector.pyx":1 - * # This file is part of ssh-python. # <<<<<<<<<<<<<< - * # Copyright (C) 2018 Panos Kittenis - * # + /* "ssh/connector.pyx":75 + * return handle_error_codes(rc, self.session._session) + * + * def set_out_channel(self, Channel channel, Flag flag): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /*--- Wrapped vars code ---*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_9Connector_7set_out_channel, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Connector_set_out_channel, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9connector_Connector, __pyx_n_s_set_out_channel, __pyx_t_2) < 0) __PYX_ERR(2, 75, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9connector_Connector); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + /* "ssh/connector.pyx":82 + * return handle_error_codes(rc, self.session._session) + * + * def set_in_fd(self, socket): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(socket) + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_9Connector_9set_in_fd, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Connector_set_in_fd, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9connector_Connector, __pyx_n_s_set_in_fd, __pyx_t_2) < 0) __PYX_ERR(2, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9connector_Connector); + + /* "ssh/connector.pyx":87 + * c_ssh.ssh_connector_set_in_fd(self._connector, _sock) + * + * def set_out_fd(self, socket): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(socket) + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_9Connector_11set_out_fd, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Connector_set_out_fd, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_9connector_Connector, __pyx_n_s_set_out_fd, __pyx_t_2) < 0) __PYX_ERR(2, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_9connector_Connector); + + /* "(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_3ssh_9connector_9Connector_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Connector___reduce_cython, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_9Connector_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Connector___setstate_cython, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Flag(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_9connector_1__pyx_unpickle_Flag, 0, __pyx_n_s_pyx_unpickle_Flag, NULL, __pyx_n_s_ssh_connector, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Flag, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "ssh/connector.pyx":1 + * # This file is part of ssh-python. # <<<<<<<<<<<<<< + * # Copyright (C) 2018 Panos Kittenis + * # + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init ssh.connector", __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 ssh.connector"); } @@ -4449,6 +7249,22 @@ if (!__Pyx_RefNanny) { return; #endif } +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ @@ -4468,6 +7284,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { @@ -4482,10 +7400,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject } #endif +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); @@ -4496,9 +7443,236 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; itp_name, Py_TYPE(obj)->tp_name); + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); return 0; } -/* PyCFunctionFastCall */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); - } -} -#endif - /* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; @@ -4570,7 +7725,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args --tstate->recursion_depth; return result; } -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); @@ -4586,9 +7740,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } + #endif if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && @@ -4657,7 +7817,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, return result; } #endif -#endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON @@ -4666,8 +7825,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -4684,10 +7848,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -4699,131 +7868,186 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject } #endif -/* PyObjectCallOneArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); return result; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); - } #endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (__Pyx_PyFastCFunction_Check(func)) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } #endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); } } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -#endif - -/* PyObjectCallNoArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); } -#endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) -#endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif } -#endif -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); } -#endif -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; #endif - -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS -#if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); #else - if (likely(PyString_Check(n))) + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; #endif - return __Pyx_PyObject_GetAttrStr(o, n); + goto invalid_keyword; + } +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; #endif - return PyObject_GetAttr(o, n); + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } +#endif + return 1; + } + while (PyDict_Next(kw, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if (!kw_allowed && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; } /* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -4833,9 +8057,25 @@ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { Py_INCREF(d); return d; } +#endif static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r = __Pyx_GetAttr(o, n); + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyString_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif } /* PyDictVersioning */ @@ -4873,7 +8113,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { @@ -4881,6 +8121,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) } else if (unlikely(PyErr_Occurred())) { return NULL; } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) @@ -4916,6 +8164,7 @@ static void __Pyx_RaiseDoubleKeywordsError( /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, + PyObject *const *kwvalues, PyObject **argnames[], PyObject *kwds2, PyObject *values[], @@ -4926,13 +8175,54 @@ static int __Pyx_ParseOptionalKeywords( Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; - while (PyDict_Next(kwds, &pos, &key, &value)) { + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; continue; } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { @@ -4940,6 +8230,9 @@ static int __Pyx_ParseOptionalKeywords( if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif break; } name++; @@ -4960,14 +8253,18 @@ static int __Pyx_ParseOptionalKeywords( #endif if (likely(PyUnicode_Check(key))) { while (*name) { - int cmp = (**name == key) ? 0 : + int cmp = ( #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif - PyUnicode_Compare(**name, key); + PyUnicode_Compare(**name, key) + ); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif break; } name++; @@ -4994,6 +8291,8 @@ static int __Pyx_ParseOptionalKeywords( goto invalid_keyword; } } + Py_XDECREF(key); + Py_XDECREF(value); return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); @@ -5003,49 +8302,37 @@ static int __Pyx_ParseOptionalKeywords( "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: - PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else + PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: + Py_XDECREF(key); + Py_XDECREF(value); return -1; } -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) { - 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); + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; } /* RaiseException */ #if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); Py_XINCREF(type); if (!value || value == Py_None) value = NULL; @@ -5178,13 +8465,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } PyErr_SetObject(type, value); if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else + #if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { @@ -5192,6 +8475,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); #endif } bad: @@ -5202,39 +8491,32 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *empty_list = 0; PyObject *module = 0; - PyObject *global_dict = 0; PyObject *empty_dict = 0; - PyObject *list; + PyObject *empty_list = 0; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (!py_import) + if (unlikely(!py_import)) goto bad; - #endif - if (from_list) - list = from_list; - else { + if (!from_list) { empty_list = PyList_New(0); - if (!empty_list) + if (unlikely(!empty_list)) goto bad; - list = empty_list; + from_list = empty_list; } - global_dict = PyModule_GetDict(__pyx_m); - if (!global_dict) - goto bad; + #endif empty_dict = PyDict_New(); - if (!empty_dict) + if (unlikely(!empty_dict)) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { - if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, 1); - if (!module) { - if (!PyErr_ExceptionMatches(PyExc_ImportError)) + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } @@ -5245,23 +8527,23 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); - if (!py_level) + if (unlikely(!py_level)) goto bad; module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); + name, __pyx_d, empty_dict, from_list, level); #endif } } bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); return module; } @@ -5269,6 +8551,35 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__2); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); @@ -5279,36 +8590,21 @@ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { return value; } -/* PyObjectCall2Args */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { - PyObject *args, *result = NULL; - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyFunction_FastCall(function, args, 2); - } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); - } - #endif - args = PyTuple_New(2); - if (unlikely(!args)) goto done; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - Py_INCREF(function); - result = __Pyx_PyObject_Call(function, args, NULL); - Py_DECREF(args); - Py_DECREF(function); -done: - return result; +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); } /* HasAttr */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { @@ -5317,7 +8613,7 @@ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { return -1; } r = __Pyx_GetAttr(o, n); - if (unlikely(!r)) { + if (!r) { PyErr_Clear(); return 0; } else { @@ -5325,18 +8621,390 @@ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { return 1; } } +#endif + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#endif + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); #endif + __Pyx_DECREF_TypeName(type_name); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { @@ -5377,15 +9045,15 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif - if (!ob) - goto bad; - if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; @@ -5394,33 +9062,85 @@ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { return -1; } -/* PyObjectGetAttrStrNoError */ -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; + { + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; + } } -#endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { + void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); + if (base_vtable != NULL) { + int j; + PyTypeObject* base = type->tp_base; + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = base->tp_base; + } + } } - return result; + PyErr_Clear(); + free(base_vtables); + return 0; +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; } +#endif /* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { @@ -5486,7 +9206,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); @@ -5502,8 +9222,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } goto __PYX_GOOD; __PYX_BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP @@ -5519,18 +9244,21 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { Py_XDECREF(setstate_cython); return ret; } +#endif /* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; -#ifdef Py_LIMITED_API + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; + PyObject *py_itemsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) @@ -5541,8 +9269,9 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, module_name, class_name); goto bad; } -#ifndef Py_LIMITED_API +#if !CYTHON_COMPILING_IN_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) @@ -5552,22 +9281,38 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; #endif - if ((size_t)basicsize < size) { + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + module_name, class_name, size, basicsize+itemsize); goto bad; } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", @@ -5580,35 +9325,1193 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, return NULL; } #endif - -/* GetVTable */ -static void* __Pyx_GetVtable(PyObject *dict) { - void* ptr; - PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); - if (!ob) - goto bad; -#if PY_VERSION_HEX >= 0x02070000 - ptr = PyCapsule_GetPointer(ob, 0); + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), +#endif + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); #else - ptr = PyCObject_AsVoidPtr(ob); + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #endif - if (!ptr && !PyErr_Occurred()) - PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); - Py_DECREF(ob); - return ptr; -bad: - Py_XDECREF(ob); - return NULL; + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -5622,7 +10525,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -5644,6 +10547,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -5722,17 +10626,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -5767,6 +10755,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -5782,7 +10771,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -5829,6 +10818,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -5885,8 +10875,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__ssh_connector_flags_e(enum { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(enum ssh_connector_flags_e), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(enum ssh_connector_flags_e)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -5903,7 +10919,7 @@ static CYTHON_INLINE enum ssh_connector_flags_e __Pyx_PyInt_As_enum__ssh_connect const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(enum ssh_connector_flags_e) < sizeof(long)) { + if ((sizeof(enum ssh_connector_flags_e) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -5917,40 +10933,45 @@ static CYTHON_INLINE enum ssh_connector_flags_e __Pyx_PyInt_As_enum__ssh_connect if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (enum ssh_connector_flags_e) 0; - case 1: __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, digit, digits[0]) - case 2: - if (8 * sizeof(enum ssh_connector_flags_e) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(enum ssh_connector_flags_e) >= 2 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) (((((enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, __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(enum ssh_connector_flags_e) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(enum ssh_connector_flags_e) >= 2 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) (((((enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(enum ssh_connector_flags_e) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(enum ssh_connector_flags_e) >= 3 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) (((((((enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0])); + break; + case 3: + if ((8 * sizeof(enum ssh_connector_flags_e) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(enum ssh_connector_flags_e) >= 3 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) (((((((enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(enum ssh_connector_flags_e) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, 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(enum ssh_connector_flags_e) >= 4 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) (((((((((enum ssh_connector_flags_e)digits[3]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0])); + break; + case 4: + if ((8 * sizeof(enum ssh_connector_flags_e) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, 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(enum ssh_connector_flags_e) >= 4 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) (((((((((enum ssh_connector_flags_e)digits[3]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -5963,111 +10984,89 @@ static CYTHON_INLINE enum ssh_connector_flags_e __Pyx_PyInt_As_enum__ssh_connect goto raise_neg_overflow; } #endif - if (sizeof(enum ssh_connector_flags_e) <= sizeof(unsigned long)) { + if ((sizeof(enum ssh_connector_flags_e) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(enum ssh_connector_flags_e, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(enum ssh_connector_flags_e) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(enum ssh_connector_flags_e) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(enum ssh_connector_flags_e, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (enum ssh_connector_flags_e) 0; - case -1: __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, digit, +digits[0]) - case -2: - if (8 * sizeof(enum ssh_connector_flags_e) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(enum ssh_connector_flags_e) - 1 > 2 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) (((enum ssh_connector_flags_e)-1)*(((((enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, __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(enum ssh_connector_flags_e) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(enum ssh_connector_flags_e) - 1 > 2 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) (((enum ssh_connector_flags_e)-1)*(((((enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(enum ssh_connector_flags_e) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(enum ssh_connector_flags_e) - 1 > 2 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) ((((((enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + break; + case 2: + if ((8 * sizeof(enum ssh_connector_flags_e) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(enum ssh_connector_flags_e) - 1 > 2 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) ((((((enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(enum ssh_connector_flags_e) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(enum ssh_connector_flags_e) - 1 > 3 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) (((enum ssh_connector_flags_e)-1)*(((((((enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + break; + case -3: + if ((8 * sizeof(enum ssh_connector_flags_e) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(enum ssh_connector_flags_e) - 1 > 3 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) (((enum ssh_connector_flags_e)-1)*(((((((enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(enum ssh_connector_flags_e) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(enum ssh_connector_flags_e) - 1 > 3 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) ((((((((enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + break; + case 3: + if ((8 * sizeof(enum ssh_connector_flags_e) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(enum ssh_connector_flags_e) - 1 > 3 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) ((((((((enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(enum ssh_connector_flags_e) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, 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(enum ssh_connector_flags_e) - 1 > 4 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) (((enum ssh_connector_flags_e)-1)*(((((((((enum ssh_connector_flags_e)digits[3]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + break; + case -4: + if ((8 * sizeof(enum ssh_connector_flags_e) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, 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(enum ssh_connector_flags_e) - 1 > 4 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) (((enum ssh_connector_flags_e)-1)*(((((((((enum ssh_connector_flags_e)digits[3]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(enum ssh_connector_flags_e) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, 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(enum ssh_connector_flags_e) - 1 > 4 * PyLong_SHIFT) { - return (enum ssh_connector_flags_e) ((((((((((enum ssh_connector_flags_e)digits[3]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + break; + case 4: + if ((8 * sizeof(enum ssh_connector_flags_e) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(enum ssh_connector_flags_e, 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(enum ssh_connector_flags_e) - 1 > 4 * PyLong_SHIFT)) { + return (enum ssh_connector_flags_e) ((((((((((enum ssh_connector_flags_e)digits[3]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[2]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[1]) << PyLong_SHIFT) | (enum ssh_connector_flags_e)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(enum ssh_connector_flags_e) <= sizeof(long)) { + if ((sizeof(enum ssh_connector_flags_e) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(enum ssh_connector_flags_e, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(enum ssh_connector_flags_e) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(enum ssh_connector_flags_e) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(enum ssh_connector_flags_e, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } - { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else - enum ssh_connector_flags_e val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } - #endif - if (likely(v)) { - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); - Py_DECREF(v); - if (likely(!ret)) - return val; - } -#endif - return (enum ssh_connector_flags_e) -1; - } + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available, cannot convert large enums"); + return (enum ssh_connector_flags_e) -1; } else { enum ssh_connector_flags_e val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); @@ -6099,7 +11098,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -6113,40 +11112,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -6159,109 +11163,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -6315,8 +11391,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -6353,10 +11455,52 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__18); } + return name; } +#endif /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { @@ -6371,7 +11515,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -6385,40 +11529,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -6431,109 +11580,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -6558,7 +11779,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -6579,6 +11800,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -6603,11 +11840,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -6655,47 +11892,56 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionImport */ -#ifndef __PYX_HAVE_RT_ImportFunction -#define __PYX_HAVE_RT_ImportFunction -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { +#ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { @@ -6712,7 +11958,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** PyModule_GetName(module), funcname); goto bad; } -#if PY_VERSION_HEX >= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", @@ -6720,21 +11965,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); -#else - {const char *desc, *s1, *s2; - desc = (const char *)PyCObject_GetDesc(cobj); - if (!desc) - goto bad; - s1 = desc; s2 = sig; - while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } - if (*s1 != *s2) { - PyErr_Format(PyExc_TypeError, - "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", - PyModule_GetName(module), funcname, sig, desc); - goto bad; - } - tmp.p = PyCObject_AsVoidPtr(cobj);} -#endif *f = tmp.fp; if (!(*f)) goto bad; @@ -6747,9 +11977,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** #endif /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -6757,30 +12009,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -6835,7 +12091,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -6864,22 +12120,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -6945,13 +12205,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -7019,4 +12277,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/error_codes.c b/ssh/error_codes.c index f7ad8b6d..1c63a36e 100644 --- a/ssh/error_codes.c +++ b/ssh/error_codes.c @@ -1,22 +1,72 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.error_codes", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/error_codes.pyx" + ] + }, + "module_name": "ssh.error_codes" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +85,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +93,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +130,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +150,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +278,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +307,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +318,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +341,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +368,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +392,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) + #endif + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +476,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +500,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +517,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +579,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +614,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +766,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +783,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#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_PyFastCFunction_Check(func) 0 + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +873,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +919,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +953,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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 + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1047,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1062,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1104,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1121,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1168,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1188,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1228,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -793,9 +1304,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -813,9 +1325,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -823,13 +1335,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -853,8 +1359,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -875,7 +1427,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -905,6 +1457,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -940,24 +1493,26 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "ssh/error_codes.pyx", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -966,11 +1521,11 @@ static const char *__pyx_f[] = { #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -980,28 +1535,40 @@ static const char *__pyx_f[] = { #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1012,6 +1579,10 @@ static const char *__pyx_f[] = { #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);\ @@ -1049,22 +1620,30 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1076,7 +1655,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1092,6 +1671,16 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) @@ -1100,6 +1689,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1113,18 +1703,32 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1138,37 +1742,48 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "libc.time" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'ssh.error_codes' */ +/* Module declarations from "ssh.error_codes" */ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.error_codes" extern int __pyx_module_is_main_ssh__error_codes; int __pyx_module_is_main_ssh__error_codes = 0; -/* Implementation of 'ssh.error_codes' */ +/* Implementation of "ssh.error_codes" */ +/* #### Code section: global_var ### */ +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = "?"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; @@ -1177,51 +1792,185 @@ static const char __pyx_k_SSH_EOF[] = "SSH_EOF"; static const char __pyx_k_SSH_AGAIN[] = "SSH_AGAIN"; static const char __pyx_k_SSH_ERROR[] = "SSH_ERROR"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static PyObject *__pyx_n_s_SSH_AGAIN; -static PyObject *__pyx_n_s_SSH_EOF; -static PyObject *__pyx_n_s_SSH_ERROR; -static PyObject *__pyx_n_s_SSH_OK; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_test; -/* Late includes */ - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; +/* #### Code section: decls ### */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyObject *__pyx_n_s_; + PyObject *__pyx_n_s_SSH_AGAIN; + PyObject *__pyx_n_s_SSH_EOF; + PyObject *__pyx_n_s_SSH_ERROR; + PyObject *__pyx_n_s_SSH_OK; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_test; +} __pyx_mstate; -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_error_codes(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_error_codes}, - {0, NULL} -}; +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; #endif -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "error_codes", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; + Py_CLEAR(clear_module_state->__pyx_n_s_); + Py_CLEAR(clear_module_state->__pyx_n_s_SSH_AGAIN); + Py_CLEAR(clear_module_state->__pyx_n_s_SSH_EOF); + Py_CLEAR(clear_module_state->__pyx_n_s_SSH_ERROR); + Py_CLEAR(clear_module_state->__pyx_n_s_SSH_OK); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_n_s_); + Py_VISIT(traverse_module_state->__pyx_n_s_SSH_AGAIN); + Py_VISIT(traverse_module_state->__pyx_n_s_SSH_EOF); + Py_VISIT(traverse_module_state->__pyx_n_s_SSH_ERROR); + Py_VISIT(traverse_module_state->__pyx_n_s_SSH_OK); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE #endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_n_s_ __pyx_mstate_global->__pyx_n_s_ +#define __pyx_n_s_SSH_AGAIN __pyx_mstate_global->__pyx_n_s_SSH_AGAIN +#define __pyx_n_s_SSH_EOF __pyx_mstate_global->__pyx_n_s_SSH_EOF +#define __pyx_n_s_SSH_ERROR __pyx_mstate_global->__pyx_n_s_SSH_ERROR +#define __pyx_n_s_SSH_OK __pyx_mstate_global->__pyx_n_s_SSH_OK +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +/* #### Code section: module_code ### */ + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -1231,21 +1980,28 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif +/* #### Code section: pystring_table ### */ -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_SSH_AGAIN, __pyx_k_SSH_AGAIN, sizeof(__pyx_k_SSH_AGAIN), 0, 0, 1, 1}, - {&__pyx_n_s_SSH_EOF, __pyx_k_SSH_EOF, sizeof(__pyx_k_SSH_EOF), 0, 0, 1, 1}, - {&__pyx_n_s_SSH_ERROR, __pyx_k_SSH_ERROR, sizeof(__pyx_k_SSH_ERROR), 0, 0, 1, 1}, - {&__pyx_n_s_SSH_OK, __pyx_k_SSH_OK, sizeof(__pyx_k_SSH_OK), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1}, + {&__pyx_n_s_SSH_AGAIN, __pyx_k_SSH_AGAIN, sizeof(__pyx_k_SSH_AGAIN), 0, 0, 1, 1}, + {&__pyx_n_s_SSH_EOF, __pyx_k_SSH_EOF, sizeof(__pyx_k_SSH_EOF), 0, 0, 1, 1}, + {&__pyx_n_s_SSH_ERROR, __pyx_k_SSH_ERROR, sizeof(__pyx_k_SSH_ERROR), 0, 0, 1, 1}, + {&__pyx_n_s_SSH_OK, __pyx_k_SSH_OK, sizeof(__pyx_k_SSH_OK), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { return 0; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations @@ -1253,13 +2009,20 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyFinishContext(); return 0; } +/* #### Code section: init_constants ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -1326,6 +2089,55 @@ static int __Pyx_modinit_function_import_code(void) { } +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_error_codes(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_error_codes}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "error_codes", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 @@ -1376,12 +2188,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -1391,8 +2212,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -1402,8 +2224,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -1419,7 +2245,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_error_codes(PyObject *__pyx_pyinit #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -1433,6 +2264,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_error_codes(PyObject *__pyx_pyinit #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("error_codes", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "error_codes" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -1443,7 +2301,7 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_error_codes(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif @@ -1451,48 +2309,31 @@ if (!__Pyx_RefNanny) { __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("error_codes", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -1504,7 +2345,7 @@ if (!__Pyx_RefNanny) { { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "ssh.error_codes")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.error_codes", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "ssh.error_codes", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif @@ -1532,10 +2373,10 @@ if (!__Pyx_RefNanny) { * SSH_EOF = c_ssh.SSH_EOF * SSH_ERROR = c_ssh.SSH_ERROR */ - __pyx_t_1 = __Pyx_PyInt_From_int(SSH_OK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_OK, __pyx_t_1) < 0) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(SSH_OK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_OK, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "ssh/error_codes.pyx":21 * @@ -1544,10 +2385,10 @@ if (!__Pyx_RefNanny) { * SSH_ERROR = c_ssh.SSH_ERROR * SSH_AGAIN = c_ssh.SSH_AGAIN */ - __pyx_t_1 = __Pyx_PyInt_From_int(SSH_EOF); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_EOF, __pyx_t_1) < 0) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(SSH_EOF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_EOF, __pyx_t_2) < 0) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "ssh/error_codes.pyx":22 * SSH_OK = c_ssh.SSH_OK @@ -1555,41 +2396,51 @@ if (!__Pyx_RefNanny) { * SSH_ERROR = c_ssh.SSH_ERROR # <<<<<<<<<<<<<< * SSH_AGAIN = c_ssh.SSH_AGAIN */ - __pyx_t_1 = __Pyx_PyInt_From_int(SSH_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_ERROR, __pyx_t_1) < 0) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(SSH_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "ssh/error_codes.pyx":23 * SSH_EOF = c_ssh.SSH_EOF * SSH_ERROR = c_ssh.SSH_ERROR * SSH_AGAIN = c_ssh.SSH_AGAIN # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyInt_From_int(SSH_AGAIN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_AGAIN, __pyx_t_1) < 0) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(SSH_AGAIN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH_AGAIN, __pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "ssh/error_codes.pyx":1 * # This file is part of ssh-python. # <<<<<<<<<<<<<< * # Copyright (C) 2018 Panos Kittenis * # */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init ssh.error_codes", __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 ssh.error_codes"); } @@ -1603,6 +2454,22 @@ if (!__Pyx_RefNanny) { return; #endif } +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ @@ -1648,23 +2515,67 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN } #endif -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; @@ -1675,25 +2586,89 @@ static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObjec Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); +#endif } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); } #endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -1707,7 +2682,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -1729,6 +2704,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -1807,17 +2783,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -1852,6 +2912,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -1867,7 +2928,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -1914,9 +2975,10 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" @@ -1948,11 +3010,53 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s_); + } + return name; +} +#endif + /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC @@ -1986,8 +3090,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -2026,7 +3156,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -2040,40 +3170,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -2086,109 +3221,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -2222,7 +3429,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -2236,40 +3443,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -2282,109 +3494,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -2409,7 +3693,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -2430,6 +3714,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -2454,11 +3754,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -2506,47 +3806,78 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -2554,30 +3885,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -2632,7 +3967,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -2661,22 +3996,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -2742,13 +4081,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -2816,4 +4153,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/event.c b/ssh/event.c index 329cc006..bc6b4d20 100644 --- a/ssh/event.c +++ b/ssh/event.c @@ -1,22 +1,89 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.event", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/event.pyx" + ] + }, + "module_name": "ssh.event" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" + + #if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj) + #else + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj, NULL) + #endif + + + #if PY_MAJOR_VERSION <= 2 + #define PyDict_GetItemWithError _PyDict_GetItemWithError + #endif + + + #if (PY_VERSION_HEX < 0x030700b1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030600)) && !defined(PyContextVar_Get) + #define PyContextVar_Get(var, d, v) ((d) ? ((void)(var), Py_INCREF(d), (v)[0] = (d), 0) : ((v)[0] = NULL, 0) ) + #endif + #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +102,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +110,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +147,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +167,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +295,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +324,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +335,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +358,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +385,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +409,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +493,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +517,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +534,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +596,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +631,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +783,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +800,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +890,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +936,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +970,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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 + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1064,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1079,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1121,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1138,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1185,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1205,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1245,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -796,9 +1324,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -816,9 +1345,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -826,13 +1355,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -856,8 +1379,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -878,7 +1447,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -908,6 +1477,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -943,28 +1513,32 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "ssh/event.pyx", - "stringsource", + "", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/contextvars.pxd", "ssh/session.pxd", "ssh/connector.pxd", - "env/lib/python3.9/site-packages/Cython/Includes/cpython/type.pxd", - "env/lib/python3.9/site-packages/Cython/Includes/cpython/bool.pxd", - "env/lib/python3.9/site-packages/Cython/Includes/cpython/complex.pxd", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/type.pxd", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/bool.pxd", + "venv/lib/python3.10/site-packages/Cython/Includes/cpython/complex.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -972,17 +1546,41 @@ static const char *__pyx_f[] = { #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_3ssh_7session_Session; struct __pyx_obj_3ssh_9connector_Flag; struct __pyx_obj_3ssh_9connector_Connector; struct __pyx_obj_3ssh_5event_Event; +struct __pyx_opt_args_7cpython_11contextvars_get_value; +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default; + +/* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value { + int __pyx_n; + PyObject *default_value; +}; + +/* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default { + int __pyx_n; + PyObject *default_value; +}; /* "session.pxd":19 * cimport c_ssh @@ -1087,6 +1685,7 @@ struct __pyx_vtabstruct_3ssh_5event_Event { int (*event_callback)(socket_t, int, void *); }; static struct __pyx_vtabstruct_3ssh_5event_Event *__pyx_vtabptr_3ssh_5event_Event; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1095,11 +1694,11 @@ static struct __pyx_vtabstruct_3ssh_5event_Event *__pyx_vtabptr_3ssh_5event_Even #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1109,28 +1708,40 @@ static struct __pyx_vtabstruct_3ssh_5event_Event *__pyx_vtabptr_3ssh_5event_Even #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1141,6 +1752,10 @@ static struct __pyx_vtabstruct_3ssh_5event_Event *__pyx_vtabptr_3ssh_5event_Even #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);\ @@ -1152,6 +1767,57 @@ static struct __pyx_vtabstruct_3ssh_5event_Event *__pyx_vtabptr_3ssh_5event_Even #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); @@ -1159,45 +1825,116 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif -#if CYTHON_FAST_PYCALL - static size_t __pyx_pyframe_localsplus_offset = 0; +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif // CYTHON_FAST_PYCALL +#endif +#endif #endif /* PyObjectCall.proto */ @@ -1212,39 +1949,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) -#endif - -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); -#else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) -#endif - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); /* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) @@ -1256,14 +1969,6 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) @@ -1272,53 +1977,52 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* WriteUnraisableException.proto */ -static void __Pyx_WriteUnraisable(const char *name, int clineno, - int lineno, const char *filename, - int full_traceback, int nogil); - /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); @@ -1334,27 +2038,179 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 }; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); #endif -/* GetVTable.proto */ -static void* __Pyx_GetVtable(PyObject *dict); +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -1390,6 +2246,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1403,13 +2260,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif @@ -1422,6 +2280,19 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1431,174 +2302,202 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionImport.proto */ -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self); /* proto*/ static struct __pyx_obj_3ssh_5event_Event *__pyx_f_3ssh_5event_5Event_from_ptr(ssh_event __pyx_v__event); /* proto*/ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __pyx_v_fd, CYTHON_UNUSED int __pyx_v_revent, void *__pyx_v_userdata); /* proto*/ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "libc.time" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'ssh.session' */ -static PyTypeObject *__pyx_ptype_3ssh_7session_Session = 0; +/* Module declarations from "ssh.session" */ -/* Module declarations from 'ssh.connector' */ -static PyTypeObject *__pyx_ptype_3ssh_9connector_Flag = 0; -static PyTypeObject *__pyx_ptype_3ssh_9connector_Connector = 0; +/* Module declarations from "ssh.connector" */ -/* Module declarations from 'cpython.version' */ +/* Module declarations from "cpython.version" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from "cpython.type" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'libc.stdio' */ +/* Module declarations from "libc.stdio" */ -/* Module declarations from 'cpython.object' */ +/* Module declarations from "cpython.object" */ -/* Module declarations from 'cpython.ref' */ +/* Module declarations from "cpython.ref" */ -/* Module declarations from 'cpython.exc' */ +/* Module declarations from "cpython.exc" */ -/* Module declarations from 'cpython.module' */ +/* Module declarations from "cpython.module" */ -/* Module declarations from 'cpython.mem' */ +/* Module declarations from "cpython.mem" */ -/* Module declarations from 'cpython.tuple' */ +/* Module declarations from "cpython.tuple" */ -/* Module declarations from 'cpython.list' */ +/* Module declarations from "cpython.list" */ -/* Module declarations from 'cpython.sequence' */ +/* Module declarations from "cpython.sequence" */ -/* Module declarations from 'cpython.mapping' */ +/* Module declarations from "cpython.mapping" */ -/* Module declarations from 'cpython.iterator' */ +/* Module declarations from "cpython.iterator" */ -/* Module declarations from 'cpython.number' */ +/* Module declarations from "cpython.number" */ -/* Module declarations from 'cpython.int' */ +/* Module declarations from "cpython.int" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from 'cpython.bool' */ -static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; +/* Module declarations from "cpython.bool" */ -/* Module declarations from 'cpython.long' */ +/* Module declarations from "cpython.long" */ -/* Module declarations from 'cpython.float' */ +/* Module declarations from "cpython.float" */ -/* Module declarations from '__builtin__' */ +/* Module declarations from "__builtin__" */ -/* Module declarations from 'cpython.complex' */ -static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; +/* Module declarations from "cpython.complex" */ -/* Module declarations from 'cpython.string' */ +/* Module declarations from "cpython.string" */ -/* Module declarations from 'cpython.unicode' */ +/* Module declarations from "cpython.unicode" */ -/* Module declarations from 'cpython.dict' */ +/* Module declarations from "cpython.pyport" */ -/* Module declarations from 'cpython.instance' */ +/* Module declarations from "cpython.dict" */ -/* Module declarations from 'cpython.function' */ +/* Module declarations from "cpython.instance" */ -/* Module declarations from 'cpython.method' */ +/* Module declarations from "cpython.function" */ -/* Module declarations from 'cpython.weakref' */ +/* Module declarations from "cpython.method" */ -/* Module declarations from 'cpython.getargs' */ +/* Module declarations from "cpython.weakref" */ -/* Module declarations from 'cpython.pythread' */ +/* Module declarations from "cpython.getargs" */ -/* Module declarations from 'cpython.pystate' */ +/* Module declarations from "cpython.pythread" */ -/* Module declarations from 'cpython.cobject' */ +/* Module declarations from "cpython.pystate" */ -/* Module declarations from 'cpython.oldbuffer' */ +/* Module declarations from "cpython.cobject" */ -/* Module declarations from 'cpython.set' */ +/* Module declarations from "cpython.oldbuffer" */ -/* Module declarations from 'cpython.buffer' */ +/* Module declarations from "cpython.set" */ -/* Module declarations from 'cpython.bytes' */ +/* Module declarations from "cpython.buffer" */ -/* Module declarations from 'cpython.pycapsule' */ +/* Module declarations from "cpython.bytes" */ -/* Module declarations from 'cpython' */ +/* Module declarations from "cpython.pycapsule" */ -/* Module declarations from 'ssh.utils' */ +/* Module declarations from "cpython.contextvars" */ + +/* Module declarations from "cpython" */ + +/* Module declarations from "ssh.utils" */ static int (*__pyx_f_3ssh_5utils_handle_error_codes)(int, ssh_session); /*proto*/ -/* Module declarations from 'ssh.event' */ -static PyTypeObject *__pyx_ptype_3ssh_5event_Event = 0; +/* Module declarations from "ssh.event" */ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.event" extern int __pyx_module_is_main_ssh__event; int __pyx_module_is_main_ssh__event = 0; -/* Implementation of 'ssh.event' */ +/* Implementation of "ssh.event" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_TypeError; +/* #### Code section: string_decls ### */ +static const char __pyx_k_cb[] = "cb"; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_rc[] = "rc"; +static const char __pyx_k__18[] = "?"; +static const char __pyx_k_cb_2[] = "_cb"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_sock[] = "sock"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_Event[] = "Event"; +static const char __pyx_k_add_fd[] = "add_fd"; +static const char __pyx_k_dopoll[] = "dopoll"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_events[] = "events"; static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_sock_2[] = "_sock"; +static const char __pyx_k_socket[] = "socket"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_session[] = "session"; +static const char __pyx_k_timeout[] = "timeout"; static const char __pyx_k_callback[] = "callback"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_connector[] = "connector"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_remove_fd[] = "remove_fd"; +static const char __pyx_k_ssh_event[] = "ssh.event"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_add_session[] = "add_session"; +static const char __pyx_k_Event_add_fd[] = "Event.add_fd"; +static const char __pyx_k_Event_dopoll[] = "Event.dopoll"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_add_connector[] = "add_connector"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_ssh_event_pyx[] = "ssh/event.pyx"; +static const char __pyx_k_remove_session[] = "remove_session"; +static const char __pyx_k_Event_remove_fd[] = "Event.remove_fd"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_remove_connector[] = "remove_connector"; +static const char __pyx_k_Event_add_session[] = "Event.add_session"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_Event_add_connector[] = "Event.add_connector"; +static const char __pyx_k_Event_remove_session[] = "Event.remove_session"; +static const char __pyx_k_Event___reduce_cython[] = "Event.__reduce_cython__"; +static const char __pyx_k_Event_remove_connector[] = "Event.remove_connector"; +static const char __pyx_k_Event___setstate_cython[] = "Event.__setstate_cython__"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static PyObject *__pyx_n_s_Event; -static PyObject *__pyx_n_s_MemoryError; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_n_s_callback; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_events; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_n_s_pyx_vtable; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_sock; -static PyObject *__pyx_n_s_test; +/* #### Code section: decls ### */ static int __pyx_pf_3ssh_5event_5Event___cinit__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self); /* proto */ static void __pyx_pf_3ssh_5event_5Event_2__dealloc__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_5event_5Event_6socket___get__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self); /* proto */ @@ -1614,186 +2513,1116 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_9connector___get__(struct __pyx_obj static PyObject *__pyx_pf_3ssh_5event_5Event_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_5event_Event *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_5event_5Event_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_5event_Event *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_3ssh_5event_Event(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -/* Late includes */ - -/* "ssh/event.pyx":29 - * cdef class Event: - * - * def __cinit__(self): # <<<<<<<<<<<<<< - * self._event = c_ssh.ssh_event_new() - * if self._event is NULL: - */ - -/* Python wrapper */ -static int __pyx_pw_3ssh_5event_5Event_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_3ssh_5event_5Event_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; - __pyx_r = __pyx_pf_3ssh_5event_5Event___cinit__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_3ssh_5event_5Event___cinit__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); - - /* "ssh/event.pyx":30 - * - * def __cinit__(self): - * self._event = c_ssh.ssh_event_new() # <<<<<<<<<<<<<< - * if self._event is NULL: - * raise MemoryError - */ - __pyx_v_self->_event = ssh_event_new(); - - /* "ssh/event.pyx":31 - * def __cinit__(self): - * self._event = c_ssh.ssh_event_new() - * if self._event is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - __pyx_t_1 = ((__pyx_v_self->_event == NULL) != 0); - if (unlikely(__pyx_t_1)) { +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_3ssh_7session_Session; + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_3ssh_9connector_Flag; + PyTypeObject *__pyx_ptype_3ssh_9connector_Connector; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4bool_bool; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_7complex_complex; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_3ssh_5event_Event; + #endif + PyTypeObject *__pyx_ptype_3ssh_5event_Event; + PyObject *__pyx_n_s_Event; + PyObject *__pyx_n_s_Event___reduce_cython; + PyObject *__pyx_n_s_Event___setstate_cython; + PyObject *__pyx_n_s_Event_add_connector; + PyObject *__pyx_n_s_Event_add_fd; + PyObject *__pyx_n_s_Event_add_session; + PyObject *__pyx_n_s_Event_dopoll; + PyObject *__pyx_n_s_Event_remove_connector; + PyObject *__pyx_n_s_Event_remove_fd; + PyObject *__pyx_n_s_Event_remove_session; + PyObject *__pyx_n_s_MemoryError; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s__18; + PyObject *__pyx_n_s_add_connector; + PyObject *__pyx_n_s_add_fd; + PyObject *__pyx_n_s_add_session; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_callback; + PyObject *__pyx_n_s_cb; + PyObject *__pyx_n_s_cb_2; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_connector; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_n_s_dopoll; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_events; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_rc; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_remove_connector; + PyObject *__pyx_n_s_remove_fd; + PyObject *__pyx_n_s_remove_session; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_session; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_sock; + PyObject *__pyx_n_s_sock_2; + PyObject *__pyx_n_s_socket; + PyObject *__pyx_n_s_ssh_event; + PyObject *__pyx_kp_s_ssh_event_pyx; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_timeout; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__4; + PyObject *__pyx_tuple__6; + PyObject *__pyx_tuple__8; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__14; + PyObject *__pyx_tuple__16; + PyObject *__pyx_codeobj__2; + PyObject *__pyx_codeobj__5; + PyObject *__pyx_codeobj__7; + PyObject *__pyx_codeobj__9; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__12; + PyObject *__pyx_codeobj__13; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__17; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif - /* "ssh/event.pyx":32 - * self._event = c_ssh.ssh_event_new() - * if self._event is NULL: - * raise MemoryError # <<<<<<<<<<<<<< +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_7session_Session); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_9connector_Flag); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_9connector_Connector); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4bool_bool); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_7complex_complex); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_5event_Event); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_5event_Event); + Py_CLEAR(clear_module_state->__pyx_n_s_Event); + Py_CLEAR(clear_module_state->__pyx_n_s_Event___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Event___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_add_connector); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_add_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_add_session); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_dopoll); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_remove_connector); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_remove_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_remove_session); + Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s__18); + Py_CLEAR(clear_module_state->__pyx_n_s_add_connector); + Py_CLEAR(clear_module_state->__pyx_n_s_add_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_add_session); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_callback); + Py_CLEAR(clear_module_state->__pyx_n_s_cb); + Py_CLEAR(clear_module_state->__pyx_n_s_cb_2); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_connector); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_n_s_dopoll); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_events); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_rc); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_remove_connector); + Py_CLEAR(clear_module_state->__pyx_n_s_remove_fd); + Py_CLEAR(clear_module_state->__pyx_n_s_remove_session); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_session); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_sock); + Py_CLEAR(clear_module_state->__pyx_n_s_sock_2); + Py_CLEAR(clear_module_state->__pyx_n_s_socket); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_event); + Py_CLEAR(clear_module_state->__pyx_kp_s_ssh_event_pyx); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_timeout); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__4); + Py_CLEAR(clear_module_state->__pyx_tuple__6); + Py_CLEAR(clear_module_state->__pyx_tuple__8); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__14); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_codeobj__2); + Py_CLEAR(clear_module_state->__pyx_codeobj__5); + Py_CLEAR(clear_module_state->__pyx_codeobj__7); + Py_CLEAR(clear_module_state->__pyx_codeobj__9); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__12); + Py_CLEAR(clear_module_state->__pyx_codeobj__13); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_7session_Session); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_9connector_Flag); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_9connector_Connector); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4bool_bool); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_7complex_complex); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_5event_Event); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_5event_Event); + Py_VISIT(traverse_module_state->__pyx_n_s_Event); + Py_VISIT(traverse_module_state->__pyx_n_s_Event___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Event___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_add_connector); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_add_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_add_session); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_dopoll); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_remove_connector); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_remove_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_remove_session); + Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s__18); + Py_VISIT(traverse_module_state->__pyx_n_s_add_connector); + Py_VISIT(traverse_module_state->__pyx_n_s_add_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_add_session); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_callback); + Py_VISIT(traverse_module_state->__pyx_n_s_cb); + Py_VISIT(traverse_module_state->__pyx_n_s_cb_2); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_connector); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_n_s_dopoll); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_events); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_rc); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_remove_connector); + Py_VISIT(traverse_module_state->__pyx_n_s_remove_fd); + Py_VISIT(traverse_module_state->__pyx_n_s_remove_session); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_session); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_sock); + Py_VISIT(traverse_module_state->__pyx_n_s_sock_2); + Py_VISIT(traverse_module_state->__pyx_n_s_socket); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_event); + Py_VISIT(traverse_module_state->__pyx_kp_s_ssh_event_pyx); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_timeout); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__4); + Py_VISIT(traverse_module_state->__pyx_tuple__6); + Py_VISIT(traverse_module_state->__pyx_tuple__8); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__14); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_codeobj__2); + Py_VISIT(traverse_module_state->__pyx_codeobj__5); + Py_VISIT(traverse_module_state->__pyx_codeobj__7); + Py_VISIT(traverse_module_state->__pyx_codeobj__9); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__12); + Py_VISIT(traverse_module_state->__pyx_codeobj__13); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_3ssh_7session_Session __pyx_mstate_global->__pyx_ptype_3ssh_7session_Session +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_3ssh_9connector_Flag __pyx_mstate_global->__pyx_ptype_3ssh_9connector_Flag +#define __pyx_ptype_3ssh_9connector_Connector __pyx_mstate_global->__pyx_ptype_3ssh_9connector_Connector +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4bool_bool __pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_7complex_complex __pyx_mstate_global->__pyx_ptype_7cpython_7complex_complex +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_3ssh_5event_Event __pyx_mstate_global->__pyx_type_3ssh_5event_Event +#endif +#define __pyx_ptype_3ssh_5event_Event __pyx_mstate_global->__pyx_ptype_3ssh_5event_Event +#define __pyx_n_s_Event __pyx_mstate_global->__pyx_n_s_Event +#define __pyx_n_s_Event___reduce_cython __pyx_mstate_global->__pyx_n_s_Event___reduce_cython +#define __pyx_n_s_Event___setstate_cython __pyx_mstate_global->__pyx_n_s_Event___setstate_cython +#define __pyx_n_s_Event_add_connector __pyx_mstate_global->__pyx_n_s_Event_add_connector +#define __pyx_n_s_Event_add_fd __pyx_mstate_global->__pyx_n_s_Event_add_fd +#define __pyx_n_s_Event_add_session __pyx_mstate_global->__pyx_n_s_Event_add_session +#define __pyx_n_s_Event_dopoll __pyx_mstate_global->__pyx_n_s_Event_dopoll +#define __pyx_n_s_Event_remove_connector __pyx_mstate_global->__pyx_n_s_Event_remove_connector +#define __pyx_n_s_Event_remove_fd __pyx_mstate_global->__pyx_n_s_Event_remove_fd +#define __pyx_n_s_Event_remove_session __pyx_mstate_global->__pyx_n_s_Event_remove_session +#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s__18 __pyx_mstate_global->__pyx_n_s__18 +#define __pyx_n_s_add_connector __pyx_mstate_global->__pyx_n_s_add_connector +#define __pyx_n_s_add_fd __pyx_mstate_global->__pyx_n_s_add_fd +#define __pyx_n_s_add_session __pyx_mstate_global->__pyx_n_s_add_session +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_callback __pyx_mstate_global->__pyx_n_s_callback +#define __pyx_n_s_cb __pyx_mstate_global->__pyx_n_s_cb +#define __pyx_n_s_cb_2 __pyx_mstate_global->__pyx_n_s_cb_2 +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_connector __pyx_mstate_global->__pyx_n_s_connector +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_n_s_dopoll __pyx_mstate_global->__pyx_n_s_dopoll +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_events __pyx_mstate_global->__pyx_n_s_events +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_remove_connector __pyx_mstate_global->__pyx_n_s_remove_connector +#define __pyx_n_s_remove_fd __pyx_mstate_global->__pyx_n_s_remove_fd +#define __pyx_n_s_remove_session __pyx_mstate_global->__pyx_n_s_remove_session +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_sock __pyx_mstate_global->__pyx_n_s_sock +#define __pyx_n_s_sock_2 __pyx_mstate_global->__pyx_n_s_sock_2 +#define __pyx_n_s_socket __pyx_mstate_global->__pyx_n_s_socket +#define __pyx_n_s_ssh_event __pyx_mstate_global->__pyx_n_s_ssh_event +#define __pyx_kp_s_ssh_event_pyx __pyx_mstate_global->__pyx_kp_s_ssh_event_pyx +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_timeout __pyx_mstate_global->__pyx_n_s_timeout +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 +#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6 +#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2 +#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5 +#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 +#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12 +#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +/* #### Code section: module_code ### */ + +/* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real * - * def __dealloc__(self): */ - PyErr_NoMemory(); __PYX_ERR(0, 32, __pyx_L1_error) - /* "ssh/event.pyx":31 - * def __cinit__(self): - * self._event = c_ssh.ssh_event_new() - * if self._event is NULL: # <<<<<<<<<<<<<< - * raise MemoryError +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self) { + double __pyx_r; + + /* "cpython/complex.pxd":20 + * @property + * cdef inline double real(self) noexcept: + * return self.cval.real # <<<<<<<<<<<<<< * + * @property */ - } + __pyx_r = __pyx_v_self->cval.real; + goto __pyx_L0; - /* "ssh/event.pyx":29 - * cdef class Event: + /* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real * - * def __cinit__(self): # <<<<<<<<<<<<<< - * self._event = c_ssh.ssh_event_new() - * if self._event is NULL: */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("ssh.event.Event.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "ssh/event.pyx":34 - * raise MemoryError +/* "cpython/complex.pxd":23 + * + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * if self._event is not NULL: - * c_ssh.ssh_event_free(self._event) */ -/* Python wrapper */ -static void __pyx_pw_3ssh_5event_5Event_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_pw_3ssh_5event_5Event_3__dealloc__(PyObject *__pyx_v_self) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_pf_3ssh_5event_5Event_2__dealloc__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self) { + double __pyx_r; + + /* "cpython/complex.pxd":24 + * @property + * cdef inline double imag(self) noexcept: + * return self.cval.imag # <<<<<<<<<<<<<< + * + * # PyTypeObject PyComplex_Type + */ + __pyx_r = __pyx_v_self->cval.imag; + goto __pyx_L0; + + /* "cpython/complex.pxd":23 + * + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag + * + */ /* function exit code */ - __Pyx_RefNannyFinishContext(); + __pyx_L0:; + return __pyx_r; } -static void __pyx_pf_3ssh_5event_5Event_2__dealloc__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self) { +/* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ + +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_value", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } + } - /* "ssh/event.pyx":35 - * - * def __dealloc__(self): - * if self._event is not NULL: # <<<<<<<<<<<<<< - * c_ssh.ssh_event_free(self._event) - * self._event = NULL + /* "cpython/contextvars.pxd":117 + * or None if no such value or default was found. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: */ - __pyx_t_1 = ((__pyx_v_self->_event != NULL) != 0); - if (__pyx_t_1) { - - /* "ssh/event.pyx":36 - * def __dealloc__(self): - * if self._event is not NULL: - * c_ssh.ssh_event_free(self._event) # <<<<<<<<<<<<<< - * self._event = NULL - * + __pyx_v_value = NULL; + + /* "cpython/contextvars.pxd":118 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) # <<<<<<<<<<<<<< + * if value is NULL: + * # context variable does not have a default */ - ssh_event_free(__pyx_v_self->_event); + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, NULL, (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 118, __pyx_L1_error) + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + __pyx_t_2 = (__pyx_v_value == NULL); + if (__pyx_t_2) { - /* "ssh/event.pyx":37 - * if self._event is not NULL: - * c_ssh.ssh_event_free(self._event) - * self._event = NULL # <<<<<<<<<<<<<< - * - * @property + /* "cpython/contextvars.pxd":121 + * if value is NULL: + * # context variable does not have a default + * pyvalue = default_value # <<<<<<<<<<<<<< + * else: + * # value or default value of context variable */ - __pyx_v_self->_event = NULL; + __Pyx_INCREF(__pyx_v_default_value); + __pyx_v_pyvalue = __pyx_v_default_value; + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + goto __pyx_L3; + } - /* "ssh/event.pyx":35 + /* "cpython/contextvars.pxd":124 + * else: + * # value or default value of context variable + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + /*else*/ { + __pyx_t_3 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_pyvalue = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cpython/contextvars.pxd":125 + * # value or default value of context variable + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue * - * def __dealloc__(self): - * if self._event is not NULL: # <<<<<<<<<<<<<< - * c_ssh.ssh_event_free(self._event) - * self._event = NULL */ + Py_XDECREF(__pyx_v_value); } + __pyx_L3:; - /* "ssh/event.pyx":34 - * raise MemoryError + /* "cpython/contextvars.pxd":126 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< + * * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * if self._event is not NULL: - * c_ssh.ssh_event_free(self._event) */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; + goto __pyx_L0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "ssh/event.pyx":40 + /* "cpython/contextvars.pxd":112 * - * @property - * def socket(self): # <<<<<<<<<<<<<< - * return self._sock * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, */ -/* Python wrapper */ + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("cpython.contextvars.get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ + +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value_no_default(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_value_no_default", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } + } + + /* "cpython/contextvars.pxd":135 + * Ignores the default value of the context variable, if any. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + */ + __pyx_v_value = NULL; + + /* "cpython/contextvars.pxd":136 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, default_value, &value) # <<<<<<<<<<<<<< + * # value of context variable or 'default_value' + * pyvalue = value + */ + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, ((PyObject *)__pyx_v_default_value), (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 136, __pyx_L1_error) + + /* "cpython/contextvars.pxd":138 + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + __pyx_t_2 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_pyvalue = __pyx_t_2; + __pyx_t_2 = 0; + + /* "cpython/contextvars.pxd":139 + * # value of context variable or 'default_value' + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue + */ + Py_XDECREF(__pyx_v_value); + + /* "cpython/contextvars.pxd":140 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; + goto __pyx_L0; + + /* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("cpython.contextvars.get_value_no_default", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "ssh/event.pyx":29 + * cdef class Event: + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._event = c_ssh.ssh_event_new() + * if self._event is NULL: + */ + +/* Python wrapper */ +static int __pyx_pw_3ssh_5event_5Event_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_3ssh_5event_5Event_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + 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_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_3ssh_5event_5Event___cinit__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_3ssh_5event_5Event___cinit__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "ssh/event.pyx":30 + * + * def __cinit__(self): + * self._event = c_ssh.ssh_event_new() # <<<<<<<<<<<<<< + * if self._event is NULL: + * raise MemoryError + */ + __pyx_v_self->_event = ssh_event_new(); + + /* "ssh/event.pyx":31 + * def __cinit__(self): + * self._event = c_ssh.ssh_event_new() + * if self._event is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + __pyx_t_1 = (__pyx_v_self->_event == NULL); + if (unlikely(__pyx_t_1)) { + + /* "ssh/event.pyx":32 + * self._event = c_ssh.ssh_event_new() + * if self._event is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + PyErr_NoMemory(); __PYX_ERR(0, 32, __pyx_L1_error) + + /* "ssh/event.pyx":31 + * def __cinit__(self): + * self._event = c_ssh.ssh_event_new() + * if self._event is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "ssh/event.pyx":29 + * cdef class Event: + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._event = c_ssh.ssh_event_new() + * if self._event is NULL: + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("ssh.event.Event.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "ssh/event.pyx":34 + * raise MemoryError + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self._event is not NULL: + * c_ssh.ssh_event_free(self._event) + */ + +/* Python wrapper */ +static void __pyx_pw_3ssh_5event_5Event_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_3ssh_5event_5Event_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_pf_3ssh_5event_5Event_2__dealloc__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_3ssh_5event_5Event_2__dealloc__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self) { + int __pyx_t_1; + + /* "ssh/event.pyx":35 + * + * def __dealloc__(self): + * if self._event is not NULL: # <<<<<<<<<<<<<< + * c_ssh.ssh_event_free(self._event) + * self._event = NULL + */ + __pyx_t_1 = (__pyx_v_self->_event != NULL); + if (__pyx_t_1) { + + /* "ssh/event.pyx":36 + * def __dealloc__(self): + * if self._event is not NULL: + * c_ssh.ssh_event_free(self._event) # <<<<<<<<<<<<<< + * self._event = NULL + * + */ + ssh_event_free(__pyx_v_self->_event); + + /* "ssh/event.pyx":37 + * if self._event is not NULL: + * c_ssh.ssh_event_free(self._event) + * self._event = NULL # <<<<<<<<<<<<<< + * + * @property + */ + __pyx_v_self->_event = NULL; + + /* "ssh/event.pyx":35 + * + * def __dealloc__(self): + * if self._event is not NULL: # <<<<<<<<<<<<<< + * c_ssh.ssh_event_free(self._event) + * self._event = NULL + */ + } + + /* "ssh/event.pyx":34 + * raise MemoryError + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * if self._event is not NULL: + * c_ssh.ssh_event_free(self._event) + */ + + /* function exit code */ +} + +/* "ssh/event.pyx":39 + * self._event = NULL + * + * @property # <<<<<<<<<<<<<< + * def socket(self): + * return self._sock + */ + +/* Python wrapper */ static PyObject *__pyx_pw_3ssh_5event_5Event_6socket_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_5event_5Event_6socket_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_3ssh_5event_5Event_6socket___get__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); /* function exit code */ @@ -1804,7 +3633,7 @@ static PyObject *__pyx_pw_3ssh_5event_5Event_6socket_1__get__(PyObject *__pyx_v_ static PyObject *__pyx_pf_3ssh_5event_5Event_6socket___get__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "ssh/event.pyx":41 * @property @@ -1818,12 +3647,12 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_6socket___get__(struct __pyx_obj_3s __pyx_r = __pyx_v_self->_sock; goto __pyx_L0; - /* "ssh/event.pyx":40 + /* "ssh/event.pyx":39 + * self._event = NULL * - * @property - * def socket(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def socket(self): * return self._sock - * */ /* function exit code */ @@ -1849,7 +3678,7 @@ static struct __pyx_obj_3ssh_5event_Event *__pyx_f_3ssh_5event_5Event_from_ptr(s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("from_ptr", 0); + __Pyx_RefNannySetupContext("from_ptr", 1); /* "ssh/event.pyx":45 * @staticmethod @@ -1859,7 +3688,7 @@ static struct __pyx_obj_3ssh_5event_Event *__pyx_f_3ssh_5event_5Event_from_ptr(s * return event */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_3ssh_5event_Event(((PyTypeObject *)__pyx_ptype_3ssh_5event_Event), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_1)); + __Pyx_GOTREF((PyObject *)__pyx_t_1); __pyx_v_event = ((struct __pyx_obj_3ssh_5event_Event *)__pyx_t_1); __pyx_t_1 = 0; @@ -1879,8 +3708,8 @@ static struct __pyx_obj_3ssh_5event_Event *__pyx_f_3ssh_5event_5Event_from_ptr(s * * @staticmethod */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v_event)); + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_event); __pyx_r = __pyx_v_event; goto __pyx_L0; @@ -1926,7 +3755,7 @@ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("event_callback", 0); + __Pyx_RefNannySetupContext("event_callback", 1); /* "ssh/event.pyx":51 * @staticmethod @@ -1965,20 +3794,27 @@ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __py */ __Pyx_INCREF(__pyx_v_func); __pyx_t_5 = __pyx_v_func; __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; } } - __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L3_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_7; @@ -2008,9 +3844,9 @@ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __py if (__pyx_t_7) { __Pyx_AddTraceback("ssh.event.Event.event_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(0, 54, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); /* "ssh/event.pyx":56 * except Exception: @@ -2026,7 +3862,6 @@ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __py goto __pyx_L6_except_return; } goto __pyx_L5_except_error; - __pyx_L5_except_error:; /* "ssh/event.pyx":51 * @staticmethod @@ -2035,6 +3870,7 @@ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __py * func = userdata * return func() */ + __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); @@ -2067,7 +3903,7 @@ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __py __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_WriteUnraisable("ssh.event.Event.event_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_AddTraceback("ssh.event.Event.event_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_func); @@ -2084,62 +3920,96 @@ static int __pyx_f_3ssh_5event_5Event_event_callback(CYTHON_UNUSED socket_t __py */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_5add_fd(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_4add_fd[] = "Event.add_fd(self, sock, short events, callback=None)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_5add_fd(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_5event_5Event_5add_fd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_4add_fd, "Event.add_fd(self, sock, short events, callback=None)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_5add_fd = {"add_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_5add_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_4add_fd}; +static PyObject *__pyx_pw_3ssh_5event_5Event_5add_fd(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_sock = 0; short __pyx_v_events; PyObject *__pyx_v_callback = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add_fd (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_events,&__pyx_n_s_callback,0}; - PyObject* values[3] = {0,0,0}; - values[2] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_events,&__pyx_n_s_callback,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sock)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sock)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 58, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_events)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_events)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 58, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("add_fd", 0, 2, 3, 1); __PYX_ERR(0, 58, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_callback); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 58, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add_fd") < 0)) __PYX_ERR(0, 58, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add_fd") < 0)) __PYX_ERR(0, 58, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -2148,10 +4018,18 @@ static PyObject *__pyx_pw_3ssh_5event_5Event_5add_fd(PyObject *__pyx_v_self, PyO __pyx_v_events = __Pyx_PyInt_As_short(values[1]); if (unlikely((__pyx_v_events == (short)-1) && PyErr_Occurred())) __PYX_ERR(0, 58, __pyx_L3_error) __pyx_v_callback = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("add_fd", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 58, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("add_fd", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 58, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.event.Event.add_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -2159,6 +4037,12 @@ static PyObject *__pyx_pw_3ssh_5event_5Event_5add_fd(PyObject *__pyx_v_self, PyO __pyx_r = __pyx_pf_3ssh_5event_5Event_4add_fd(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v_sock, __pyx_v_events, __pyx_v_callback); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2177,7 +4061,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_4add_fd(struct __pyx_obj_3ssh_5even int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("add_fd", 0); + __Pyx_RefNannySetupContext("add_fd", 1); /* "ssh/event.pyx":59 * @@ -2206,7 +4090,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_4add_fd(struct __pyx_obj_3ssh_5even * self._event, _sock, events, cb, _cb) */ __pyx_t_3 = (__pyx_v_callback == Py_None); - if ((__pyx_t_3 != 0)) { + if (__pyx_t_3) { __pyx_t_2 = NULL; } else { __pyx_t_2 = ((void *)__pyx_v_callback); @@ -2229,7 +4113,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_4add_fd(struct __pyx_obj_3ssh_5even * self._sock = sock * return rc */ - __pyx_t_3 = ((__pyx_v_rc == 0) != 0); + __pyx_t_3 = (__pyx_v_rc == 0); if (__pyx_t_3) { /* "ssh/event.pyx":67 @@ -2296,31 +4180,114 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_4add_fd(struct __pyx_obj_3ssh_5even */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_7remove_fd(PyObject *__pyx_v_self, PyObject *__pyx_v_socket); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_6remove_fd[] = "Event.remove_fd(self, socket)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_7remove_fd(PyObject *__pyx_v_self, PyObject *__pyx_v_socket) { +static PyObject *__pyx_pw_3ssh_5event_5Event_7remove_fd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_6remove_fd, "Event.remove_fd(self, socket)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_7remove_fd = {"remove_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_7remove_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_6remove_fd}; +static PyObject *__pyx_pw_3ssh_5event_5Event_7remove_fd(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_socket = 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("remove_fd (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_5event_5Event_6remove_fd(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), ((PyObject *)__pyx_v_socket)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_3ssh_5event_5Event_6remove_fd(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self, PyObject *__pyx_v_socket) { - socket_t __pyx_v__sock; - int __pyx_v_rc; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_socket,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_socket)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 70, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "remove_fd") < 0)) __PYX_ERR(0, 70, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_socket = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("remove_fd", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 70, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.event.Event.remove_fd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_5event_5Event_6remove_fd(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v_socket); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3ssh_5event_5Event_6remove_fd(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self, PyObject *__pyx_v_socket) { + socket_t __pyx_v__sock; + int __pyx_v_rc; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("remove_fd", 0); + __Pyx_RefNannySetupContext("remove_fd", 1); /* "ssh/event.pyx":71 * @@ -2342,6 +4309,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_6remove_fd(struct __pyx_obj_3ssh_5e { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2383,7 +4351,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_6remove_fd(struct __pyx_obj_3ssh_5e * self._sock = None * return rc */ - __pyx_t_2 = ((__pyx_v_rc == 0) != 0); + __pyx_t_2 = (__pyx_v_rc == 0); if (__pyx_t_2) { /* "ssh/event.pyx":76 @@ -2450,23 +4418,103 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_6remove_fd(struct __pyx_obj_3ssh_5e */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_9add_session(PyObject *__pyx_v_self, PyObject *__pyx_v_session); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_8add_session[] = "Event.add_session(self, Session session)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_9add_session(PyObject *__pyx_v_self, PyObject *__pyx_v_session) { +static PyObject *__pyx_pw_3ssh_5event_5Event_9add_session(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_8add_session, "Event.add_session(self, Session session)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_9add_session = {"add_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_9add_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_8add_session}; +static PyObject *__pyx_pw_3ssh_5event_5Event_9add_session(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 +) { + struct __pyx_obj_3ssh_7session_Session *__pyx_v_session = 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("add_session (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add_session") < 0)) __PYX_ERR(0, 79, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_session = ((struct __pyx_obj_3ssh_7session_Session *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add_session", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 79, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.event.Event.add_session", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_3ssh_7session_Session, 1, "session", 0))) __PYX_ERR(0, 79, __pyx_L1_error) - __pyx_r = __pyx_pf_3ssh_5event_5Event_8add_session(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), ((struct __pyx_obj_3ssh_7session_Session *)__pyx_v_session)); + __pyx_r = __pyx_pf_3ssh_5event_5Event_8add_session(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v_session); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2480,7 +4528,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_8add_session(struct __pyx_obj_3ssh_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("add_session", 0); + __Pyx_RefNannySetupContext("add_session", 1); /* "ssh/event.pyx":81 * def add_session(self, Session session): @@ -2492,6 +4540,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_8add_session(struct __pyx_obj_3ssh_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2542,10 +4591,10 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_8add_session(struct __pyx_obj_3ssh_ * return rc * */ - __Pyx_INCREF(((PyObject *)__pyx_v_session)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_session)); - __Pyx_GOTREF(__pyx_v_self->session); - __Pyx_DECREF(((PyObject *)__pyx_v_self->session)); + __Pyx_INCREF((PyObject *)__pyx_v_session); + __Pyx_GIVEREF((PyObject *)__pyx_v_session); + __Pyx_GOTREF((PyObject *)__pyx_v_self->session); + __Pyx_DECREF((PyObject *)__pyx_v_self->session); __pyx_v_self->session = __pyx_v_session; /* "ssh/event.pyx":85 @@ -2590,23 +4639,103 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_8add_session(struct __pyx_obj_3ssh_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_11add_connector(PyObject *__pyx_v_self, PyObject *__pyx_v_connector); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_10add_connector[] = "Event.add_connector(self, Connector connector)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_11add_connector(PyObject *__pyx_v_self, PyObject *__pyx_v_connector) { +static PyObject *__pyx_pw_3ssh_5event_5Event_11add_connector(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_10add_connector, "Event.add_connector(self, Connector connector)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_11add_connector = {"add_connector", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_11add_connector, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_10add_connector}; +static PyObject *__pyx_pw_3ssh_5event_5Event_11add_connector(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 +) { + struct __pyx_obj_3ssh_9connector_Connector *__pyx_v_connector = 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("add_connector (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_connector,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_connector)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add_connector") < 0)) __PYX_ERR(0, 87, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_connector = ((struct __pyx_obj_3ssh_9connector_Connector *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add_connector", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 87, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.event.Event.add_connector", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_connector), __pyx_ptype_3ssh_9connector_Connector, 1, "connector", 0))) __PYX_ERR(0, 87, __pyx_L1_error) - __pyx_r = __pyx_pf_3ssh_5event_5Event_10add_connector(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), ((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_connector)); + __pyx_r = __pyx_pf_3ssh_5event_5Event_10add_connector(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v_connector); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2621,7 +4750,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_10add_connector(struct __pyx_obj_3s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("add_connector", 0); + __Pyx_RefNannySetupContext("add_connector", 1); /* "ssh/event.pyx":89 * def add_connector(self, Connector connector): @@ -2633,6 +4762,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_10add_connector(struct __pyx_obj_3s { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2674,7 +4804,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_10add_connector(struct __pyx_obj_3s * self.connector = connector * return handle_error_codes(rc, connector.session._session) */ - __pyx_t_1 = ((__pyx_v_rc == 0) != 0); + __pyx_t_1 = (__pyx_v_rc == 0); if (__pyx_t_1) { /* "ssh/event.pyx":93 @@ -2684,10 +4814,10 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_10add_connector(struct __pyx_obj_3s * return handle_error_codes(rc, connector.session._session) * */ - __Pyx_INCREF(((PyObject *)__pyx_v_connector)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_connector)); - __Pyx_GOTREF(__pyx_v_self->connector); - __Pyx_DECREF(((PyObject *)__pyx_v_self->connector)); + __Pyx_INCREF((PyObject *)__pyx_v_connector); + __Pyx_GIVEREF((PyObject *)__pyx_v_connector); + __Pyx_GOTREF((PyObject *)__pyx_v_self->connector); + __Pyx_DECREF((PyObject *)__pyx_v_self->connector); __pyx_v_self->connector = __pyx_v_connector; /* "ssh/event.pyx":92 @@ -2742,28 +4872,98 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_10add_connector(struct __pyx_obj_3s */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_13dopoll(PyObject *__pyx_v_self, PyObject *__pyx_arg_timeout); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_12dopoll[] = "Event.dopoll(self, int timeout)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_13dopoll(PyObject *__pyx_v_self, PyObject *__pyx_arg_timeout) { +static PyObject *__pyx_pw_3ssh_5event_5Event_13dopoll(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_12dopoll, "Event.dopoll(self, int timeout)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_13dopoll = {"dopoll", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_13dopoll, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_12dopoll}; +static PyObject *__pyx_pw_3ssh_5event_5Event_13dopoll(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 +) { int __pyx_v_timeout; + #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("dopoll (wrapper)", 0); - assert(__pyx_arg_timeout); { - __pyx_v_timeout = __Pyx_PyInt_As_int(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "dopoll") < 0)) __PYX_ERR(0, 96, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_timeout = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_timeout == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("dopoll", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 96, __pyx_L3_error) + __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.event.Event.dopoll", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_3ssh_5event_5Event_12dopoll(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), ((int)__pyx_v_timeout)); + __pyx_r = __pyx_pf_3ssh_5event_5Event_12dopoll(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v_timeout); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2776,7 +4976,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_12dopoll(struct __pyx_obj_3ssh_5eve int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("dopoll", 0); + __Pyx_RefNannySetupContext("dopoll", 1); /* "ssh/event.pyx":98 * def dopoll(self, int timeout): @@ -2788,6 +4988,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_12dopoll(struct __pyx_obj_3ssh_5eve { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2864,23 +5065,103 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_12dopoll(struct __pyx_obj_3ssh_5eve */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_15remove_session(PyObject *__pyx_v_self, PyObject *__pyx_v_session); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_14remove_session[] = "Event.remove_session(self, Session session)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_15remove_session(PyObject *__pyx_v_self, PyObject *__pyx_v_session) { +static PyObject *__pyx_pw_3ssh_5event_5Event_15remove_session(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_14remove_session, "Event.remove_session(self, Session session)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_15remove_session = {"remove_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_15remove_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_14remove_session}; +static PyObject *__pyx_pw_3ssh_5event_5Event_15remove_session(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 +) { + struct __pyx_obj_3ssh_7session_Session *__pyx_v_session = 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("remove_session (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "remove_session") < 0)) __PYX_ERR(0, 102, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_session = ((struct __pyx_obj_3ssh_7session_Session *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("remove_session", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 102, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.event.Event.remove_session", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_3ssh_7session_Session, 1, "session", 0))) __PYX_ERR(0, 102, __pyx_L1_error) - __pyx_r = __pyx_pf_3ssh_5event_5Event_14remove_session(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), ((struct __pyx_obj_3ssh_7session_Session *)__pyx_v_session)); + __pyx_r = __pyx_pf_3ssh_5event_5Event_14remove_session(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v_session); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2894,7 +5175,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_14remove_session(struct __pyx_obj_3 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("remove_session", 0); + __Pyx_RefNannySetupContext("remove_session", 1); /* "ssh/event.pyx":104 * def remove_session(self, Session session): @@ -2906,6 +5187,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_14remove_session(struct __pyx_obj_3 { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2958,8 +5240,8 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_14remove_session(struct __pyx_obj_3 */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->session); - __Pyx_DECREF(((PyObject *)__pyx_v_self->session)); + __Pyx_GOTREF((PyObject *)__pyx_v_self->session); + __Pyx_DECREF((PyObject *)__pyx_v_self->session); __pyx_v_self->session = ((struct __pyx_obj_3ssh_7session_Session *)Py_None); /* "ssh/event.pyx":108 @@ -3004,23 +5286,103 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_14remove_session(struct __pyx_obj_3 */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_17remove_connector(PyObject *__pyx_v_self, PyObject *__pyx_v_connector); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_16remove_connector[] = "Event.remove_connector(self, Connector connector)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_17remove_connector(PyObject *__pyx_v_self, PyObject *__pyx_v_connector) { +static PyObject *__pyx_pw_3ssh_5event_5Event_17remove_connector(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_16remove_connector, "Event.remove_connector(self, Connector connector)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_17remove_connector = {"remove_connector", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_17remove_connector, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_16remove_connector}; +static PyObject *__pyx_pw_3ssh_5event_5Event_17remove_connector(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 +) { + struct __pyx_obj_3ssh_9connector_Connector *__pyx_v_connector = 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("remove_connector (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_connector,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_connector)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "remove_connector") < 0)) __PYX_ERR(0, 110, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_connector = ((struct __pyx_obj_3ssh_9connector_Connector *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("remove_connector", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 110, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.event.Event.remove_connector", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_connector), __pyx_ptype_3ssh_9connector_Connector, 1, "connector", 0))) __PYX_ERR(0, 110, __pyx_L1_error) - __pyx_r = __pyx_pf_3ssh_5event_5Event_16remove_connector(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), ((struct __pyx_obj_3ssh_9connector_Connector *)__pyx_v_connector)); + __pyx_r = __pyx_pf_3ssh_5event_5Event_16remove_connector(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v_connector); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3035,7 +5397,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_16remove_connector(struct __pyx_obj int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("remove_connector", 0); + __Pyx_RefNannySetupContext("remove_connector", 1); /* "ssh/event.pyx":112 * def remove_connector(self, Connector connector): @@ -3047,6 +5409,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_16remove_connector(struct __pyx_obj { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3088,7 +5451,7 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_16remove_connector(struct __pyx_obj * self.connector = None * return handle_error_codes(rc, connector.session._session) */ - __pyx_t_1 = ((__pyx_v_rc == 0) != 0); + __pyx_t_1 = (__pyx_v_rc == 0); if (__pyx_t_1) { /* "ssh/event.pyx":116 @@ -3099,8 +5462,8 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_16remove_connector(struct __pyx_obj */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->connector); - __Pyx_DECREF(((PyObject *)__pyx_v_self->connector)); + __Pyx_GOTREF((PyObject *)__pyx_v_self->connector); + __Pyx_DECREF((PyObject *)__pyx_v_self->connector); __pyx_v_self->connector = ((struct __pyx_obj_3ssh_9connector_Connector *)Py_None); /* "ssh/event.pyx":115 @@ -3155,9 +5518,11 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_16remove_connector(struct __pyx_obj /* Python wrapper */ static PyObject *__pyx_pw_3ssh_5event_5Event_7session_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_5event_5Event_7session_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_3ssh_5event_5Event_7session___get__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); /* function exit code */ @@ -3168,9 +5533,9 @@ static PyObject *__pyx_pw_3ssh_5event_5Event_7session_1__get__(PyObject *__pyx_v static PyObject *__pyx_pf_3ssh_5event_5Event_7session___get__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self->session)); + __Pyx_INCREF((PyObject *)__pyx_v_self->session); __pyx_r = ((PyObject *)__pyx_v_self->session); goto __pyx_L0; @@ -3192,9 +5557,11 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_7session___get__(struct __pyx_obj_3 /* Python wrapper */ static PyObject *__pyx_pw_3ssh_5event_5Event_9connector_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_5event_5Event_9connector_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_3ssh_5event_5Event_9connector___get__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); /* function exit code */ @@ -3205,9 +5572,9 @@ static PyObject *__pyx_pw_3ssh_5event_5Event_9connector_1__get__(PyObject *__pyx static PyObject *__pyx_pf_3ssh_5event_5Event_9connector___get__(struct __pyx_obj_3ssh_5event_Event *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self->connector)); + __Pyx_INCREF((PyObject *)__pyx_v_self->connector); __pyx_r = ((PyObject *)__pyx_v_self->connector); goto __pyx_L0; @@ -3220,17 +5587,45 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_9connector___get__(struct __pyx_obj /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_18__reduce_cython__[] = "Event.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_5event_5Event_19__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_18__reduce_cython__, "Event.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_19__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_18__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_5event_5Event_19__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_5event_5Event_18__reduce_cython__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self)); /* function exit code */ @@ -3241,33 +5636,28 @@ static PyObject *__pyx_pw_3ssh_5event_5Event_19__reduce_cython__(PyObject *__pyx static PyObject *__pyx_pf_3ssh_5event_5Event_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_5event_Event *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.event.Event.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3277,55 +5667,133 @@ static PyObject *__pyx_pf_3ssh_5event_5Event_18__reduce_cython__(CYTHON_UNUSED s /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_5event_5Event_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_5event_5Event_20__setstate_cython__[] = "Event.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_5event_5Event_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_5event_5Event_20__setstate_cython__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_3ssh_5event_5Event_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_5event_Event *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; +static PyObject *__pyx_pw_3ssh_5event_5Event_21__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_5event_5Event_20__setstate_cython__, "Event.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_5event_5Event_21__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_20__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_5event_5Event_21__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + 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; - __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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_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_XDECREF(__pyx_t_1); + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.event.Event.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_5event_5Event_20__setstate_cython__(((struct __pyx_obj_3ssh_5event_Event *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3ssh_5event_5Event_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_5event_Event *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(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("ssh.event.Event.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3337,12 +5805,17 @@ static struct __pyx_vtabstruct_3ssh_5event_Event __pyx_vtable_3ssh_5event_Event; static PyObject *__pyx_tp_new_3ssh_5event_Event(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_3ssh_5event_Event *p; PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif p = ((struct __pyx_obj_3ssh_5event_Event *)o); p->__pyx_vtab = __pyx_vtabptr_3ssh_5event_Event; p->_sock = Py_None; Py_INCREF(Py_None); @@ -3358,8 +5831,10 @@ static PyObject *__pyx_tp_new_3ssh_5event_Event(PyTypeObject *t, CYTHON_UNUSED P static void __pyx_tp_dealloc_3ssh_5event_Event(PyObject *o) { struct __pyx_obj_3ssh_5event_Event *p = (struct __pyx_obj_3ssh_5event_Event *)o; #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { - if (PyObject_CallFinalizerFromDealloc(o)) return; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_3ssh_5event_Event) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif PyObject_GC_UnTrack(o); @@ -3374,7 +5849,14 @@ static void __pyx_tp_dealloc_3ssh_5event_Event(PyObject *o) { Py_CLEAR(p->_sock); Py_CLEAR(p->session); Py_CLEAR(p->connector); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static int __pyx_tp_traverse_3ssh_5event_Event(PyObject *o, visitproc v, void *a) { @@ -3420,15 +5902,15 @@ static PyObject *__pyx_getprop_3ssh_5event_5Event_connector(PyObject *o, CYTHON_ } static PyMethodDef __pyx_methods_3ssh_5event_Event[] = { - {"add_fd", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_5event_5Event_5add_fd, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_4add_fd}, - {"remove_fd", (PyCFunction)__pyx_pw_3ssh_5event_5Event_7remove_fd, METH_O, __pyx_doc_3ssh_5event_5Event_6remove_fd}, - {"add_session", (PyCFunction)__pyx_pw_3ssh_5event_5Event_9add_session, METH_O, __pyx_doc_3ssh_5event_5Event_8add_session}, - {"add_connector", (PyCFunction)__pyx_pw_3ssh_5event_5Event_11add_connector, METH_O, __pyx_doc_3ssh_5event_5Event_10add_connector}, - {"dopoll", (PyCFunction)__pyx_pw_3ssh_5event_5Event_13dopoll, METH_O, __pyx_doc_3ssh_5event_5Event_12dopoll}, - {"remove_session", (PyCFunction)__pyx_pw_3ssh_5event_5Event_15remove_session, METH_O, __pyx_doc_3ssh_5event_5Event_14remove_session}, - {"remove_connector", (PyCFunction)__pyx_pw_3ssh_5event_5Event_17remove_connector, METH_O, __pyx_doc_3ssh_5event_5Event_16remove_connector}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_5event_5Event_19__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_5event_5Event_18__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_5event_5Event_21__setstate_cython__, METH_O, __pyx_doc_3ssh_5event_5Event_20__setstate_cython__}, + {"add_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_5add_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_4add_fd}, + {"remove_fd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_7remove_fd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_6remove_fd}, + {"add_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_9add_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_8add_session}, + {"add_connector", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_11add_connector, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_10add_connector}, + {"dopoll", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_13dopoll, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_12dopoll}, + {"remove_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_15remove_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_14remove_session}, + {"remove_connector", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_17remove_connector, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_16remove_connector}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_18__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_5event_5Event_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_5event_5Event_20__setstate_cython__}, {0, 0, 0, 0} }; @@ -3438,10 +5920,28 @@ static struct PyGetSetDef __pyx_getsets_3ssh_5event_Event[] = { {(char *)"connector", __pyx_getprop_3ssh_5event_5Event_connector, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_5event_Event_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_3ssh_5event_Event}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_3ssh_5event_Event}, + {Py_tp_clear, (void *)__pyx_tp_clear_3ssh_5event_Event}, + {Py_tp_methods, (void *)__pyx_methods_3ssh_5event_Event}, + {Py_tp_getset, (void *)__pyx_getsets_3ssh_5event_Event}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_5event_Event}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_5event_Event_spec = { + "ssh.event.Event", + sizeof(struct __pyx_obj_3ssh_5event_Event), + 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_3ssh_5event_Event_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_5event_Event = { PyVarObject_HEAD_INIT(0, 0) - "ssh.event.Event", /*tp_name*/ + "ssh.event.""Event", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_5event_Event), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_5event_Event, /*tp_dealloc*/ @@ -3484,7 +5984,9 @@ static PyTypeObject __pyx_type_3ssh_5event_Event = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_5event_Event, /*tp_new*/ @@ -3498,54 +6000,30 @@ static PyTypeObject __pyx_type_3ssh_5event_Event = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_event(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_event}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "event", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -3555,28 +6033,69 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_Event, __pyx_k_Event, sizeof(__pyx_k_Event), 0, 0, 1, 1}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_events, __pyx_k_events, sizeof(__pyx_k_events), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_sock, __pyx_k_sock, sizeof(__pyx_k_sock), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_Event, __pyx_k_Event, sizeof(__pyx_k_Event), 0, 0, 1, 1}, + {&__pyx_n_s_Event___reduce_cython, __pyx_k_Event___reduce_cython, sizeof(__pyx_k_Event___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Event___setstate_cython, __pyx_k_Event___setstate_cython, sizeof(__pyx_k_Event___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Event_add_connector, __pyx_k_Event_add_connector, sizeof(__pyx_k_Event_add_connector), 0, 0, 1, 1}, + {&__pyx_n_s_Event_add_fd, __pyx_k_Event_add_fd, sizeof(__pyx_k_Event_add_fd), 0, 0, 1, 1}, + {&__pyx_n_s_Event_add_session, __pyx_k_Event_add_session, sizeof(__pyx_k_Event_add_session), 0, 0, 1, 1}, + {&__pyx_n_s_Event_dopoll, __pyx_k_Event_dopoll, sizeof(__pyx_k_Event_dopoll), 0, 0, 1, 1}, + {&__pyx_n_s_Event_remove_connector, __pyx_k_Event_remove_connector, sizeof(__pyx_k_Event_remove_connector), 0, 0, 1, 1}, + {&__pyx_n_s_Event_remove_fd, __pyx_k_Event_remove_fd, sizeof(__pyx_k_Event_remove_fd), 0, 0, 1, 1}, + {&__pyx_n_s_Event_remove_session, __pyx_k_Event_remove_session, sizeof(__pyx_k_Event_remove_session), 0, 0, 1, 1}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 0, 1, 1}, + {&__pyx_n_s_add_connector, __pyx_k_add_connector, sizeof(__pyx_k_add_connector), 0, 0, 1, 1}, + {&__pyx_n_s_add_fd, __pyx_k_add_fd, sizeof(__pyx_k_add_fd), 0, 0, 1, 1}, + {&__pyx_n_s_add_session, __pyx_k_add_session, sizeof(__pyx_k_add_session), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 0, 0, 1, 1}, + {&__pyx_n_s_cb, __pyx_k_cb, sizeof(__pyx_k_cb), 0, 0, 1, 1}, + {&__pyx_n_s_cb_2, __pyx_k_cb_2, sizeof(__pyx_k_cb_2), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_connector, __pyx_k_connector, sizeof(__pyx_k_connector), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_n_s_dopoll, __pyx_k_dopoll, sizeof(__pyx_k_dopoll), 0, 0, 1, 1}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_events, __pyx_k_events, sizeof(__pyx_k_events), 0, 0, 1, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_remove_connector, __pyx_k_remove_connector, sizeof(__pyx_k_remove_connector), 0, 0, 1, 1}, + {&__pyx_n_s_remove_fd, __pyx_k_remove_fd, sizeof(__pyx_k_remove_fd), 0, 0, 1, 1}, + {&__pyx_n_s_remove_session, __pyx_k_remove_session, sizeof(__pyx_k_remove_session), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_sock, __pyx_k_sock, sizeof(__pyx_k_sock), 0, 0, 1, 1}, + {&__pyx_n_s_sock_2, __pyx_k_sock_2, sizeof(__pyx_k_sock_2), 0, 0, 1, 1}, + {&__pyx_n_s_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 0, 1, 1}, + {&__pyx_n_s_ssh_event, __pyx_k_ssh_event, sizeof(__pyx_k_ssh_event), 0, 0, 1, 1}, + {&__pyx_kp_s_ssh_event_pyx, __pyx_k_ssh_event_pyx, sizeof(__pyx_k_ssh_event_pyx), 0, 0, 1, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 32, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) @@ -3584,42 +6103,133 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_L1_error:; return -1; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "ssh/event.pyx":58 + * return -1 + * + * def add_fd(self, sock, short events, callback=None): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(sock) + * cdef c_ssh.ssh_event_callback cb = \ */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_sock, __pyx_n_s_events, __pyx_n_s_callback, __pyx_n_s_sock_2, __pyx_n_s_cb, __pyx_n_s_rc, __pyx_n_s_cb_2); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 58, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_event_pyx, __pyx_n_s_add_fd, 58, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 58, __pyx_L1_error) + __pyx_tuple__3 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "ssh/event.pyx":70 + * return rc + * + * def remove_fd(self, socket): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(socket) + * cdef int rc + */ + __pyx_tuple__4 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_socket, __pyx_n_s_sock_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_event_pyx, __pyx_n_s_remove_fd, 70, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 70, __pyx_L1_error) + + /* "ssh/event.pyx":79 + * return rc + * + * def add_session(self, Session session): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__6 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_session, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_event_pyx, __pyx_n_s_add_session, 79, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 79, __pyx_L1_error) + + /* "ssh/event.pyx":87 + * return rc + * + * def add_connector(self, Connector connector): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__8 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_connector, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_event_pyx, __pyx_n_s_add_connector, 87, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 87, __pyx_L1_error) + + /* "ssh/event.pyx":96 + * return handle_error_codes(rc, connector.session._session) + * + * def dopoll(self, int timeout): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_tuple__10 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_timeout, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_event_pyx, __pyx_n_s_dopoll, 96, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 96, __pyx_L1_error) + + /* "ssh/event.pyx":102 + * return rc + * + * def remove_session(self, Session session): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_event_pyx, __pyx_n_s_remove_session, 102, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 102, __pyx_L1_error) + + /* "ssh/event.pyx":110 + * return rc + * + * def remove_connector(self, Connector connector): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_event_pyx, __pyx_n_s_remove_connector, 110, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 110, __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): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_tuple__16 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(1, 3, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } +/* #### Code section: init_constants ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -3663,17 +6273,33 @@ static int __Pyx_modinit_type_init_code(void) { __pyx_vtabptr_3ssh_5event_Event = &__pyx_vtable_3ssh_5event_Event; __pyx_vtable_3ssh_5event_Event.from_ptr = (struct __pyx_obj_3ssh_5event_Event *(*)(ssh_event))__pyx_f_3ssh_5event_5Event_from_ptr; __pyx_vtable_3ssh_5event_Event.event_callback = (int (*)(socket_t, int, void *))__pyx_f_3ssh_5event_5Event_event_callback; - if (PyType_Ready(&__pyx_type_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_5event_Event.tp_print = 0; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_3ssh_5event_Event = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_5event_Event_spec, NULL); if (unlikely(!__pyx_ptype_3ssh_5event_Event)) __PYX_ERR(0, 27, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_5event_Event_spec, __pyx_ptype_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #else + __pyx_ptype_3ssh_5event_Event = &__pyx_type_3ssh_5event_Event; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_5event_Event->tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_5event_Event.tp_dictoffset && __pyx_type_3ssh_5event_Event.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_5event_Event.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_5event_Event->tp_dictoffset && __pyx_ptype_3ssh_5event_Event->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_5event_Event->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_3ssh_5event_Event.tp_dict, __pyx_vtabptr_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Event, (PyObject *)&__pyx_type_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - __pyx_ptype_3ssh_5event_Event = &__pyx_type_3ssh_5event_Event; + #endif + if (__Pyx_SetVtable(__pyx_ptype_3ssh_5event_Event, __pyx_vtabptr_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Event, (PyObject *) __pyx_ptype_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_5event_Event) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -3689,40 +6315,36 @@ static int __Pyx_modinit_type_import_code(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule("ssh.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("ssh.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error) + __pyx_ptype_3ssh_7session_Session = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.session", "Session", sizeof(struct __pyx_obj_3ssh_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_7session_Session) __PYX_ERR(3, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("ssh.connector"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 22, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("ssh.connector"); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_3ssh_9connector_Flag = __Pyx_ImportType(__pyx_t_1, "ssh.connector", "Flag", sizeof(struct __pyx_obj_3ssh_9connector_Flag), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_9connector_Flag) __PYX_ERR(3, 22, __pyx_L1_error) - __pyx_vtabptr_3ssh_9connector_Flag = (struct __pyx_vtabstruct_3ssh_9connector_Flag*)__Pyx_GetVtable(__pyx_ptype_3ssh_9connector_Flag->tp_dict); if (unlikely(!__pyx_vtabptr_3ssh_9connector_Flag)) __PYX_ERR(3, 22, __pyx_L1_error) - __pyx_ptype_3ssh_9connector_Connector = __Pyx_ImportType(__pyx_t_1, "ssh.connector", "Connector", sizeof(struct __pyx_obj_3ssh_9connector_Connector), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_9connector_Connector) __PYX_ERR(3, 29, __pyx_L1_error) - __pyx_vtabptr_3ssh_9connector_Connector = (struct __pyx_vtabstruct_3ssh_9connector_Connector*)__Pyx_GetVtable(__pyx_ptype_3ssh_9connector_Connector->tp_dict); if (unlikely(!__pyx_vtabptr_3ssh_9connector_Connector)) __PYX_ERR(3, 29, __pyx_L1_error) + __pyx_ptype_3ssh_9connector_Flag = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.connector", "Flag", sizeof(struct __pyx_obj_3ssh_9connector_Flag), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_9connector_Flag),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_9connector_Flag) __PYX_ERR(4, 22, __pyx_L1_error) + __pyx_vtabptr_3ssh_9connector_Flag = (struct __pyx_vtabstruct_3ssh_9connector_Flag*)__Pyx_GetVtable(__pyx_ptype_3ssh_9connector_Flag); if (unlikely(!__pyx_vtabptr_3ssh_9connector_Flag)) __PYX_ERR(4, 22, __pyx_L1_error) + __pyx_ptype_3ssh_9connector_Connector = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.connector", "Connector", sizeof(struct __pyx_obj_3ssh_9connector_Connector), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_9connector_Connector),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_9connector_Connector) __PYX_ERR(4, 29, __pyx_L1_error) + __pyx_vtabptr_3ssh_9connector_Connector = (struct __pyx_vtabstruct_3ssh_9connector_Connector*)__Pyx_GetVtable(__pyx_ptype_3ssh_9connector_Connector); if (unlikely(!__pyx_vtabptr_3ssh_9connector_Connector)) __PYX_ERR(4, 29, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 9, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), #else - sizeof(PyHeapTypeObject), + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(4, 9, __pyx_L1_error) + __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(5, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 8, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(5, 8, __pyx_L1_error) + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyBoolObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(6, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(6, 15, __pyx_L1_error) + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyComplexObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(7, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -3750,7 +6372,7 @@ static int __Pyx_modinit_function_import_code(void) { /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_3ssh_5utils_handle_error_codes, "int (int, ssh_session)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -3761,6 +6383,55 @@ static int __Pyx_modinit_function_import_code(void) { } +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_event(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_event}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "event", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 @@ -3811,12 +6482,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -3826,8 +6506,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -3837,8 +6518,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -3854,7 +6539,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_event(PyObject *__pyx_pyinit_modul #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -3868,6 +6558,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_event(PyObject *__pyx_pyinit_modul #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("event", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "event" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -3878,7 +6595,7 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_event(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif @@ -3886,48 +6603,31 @@ if (!__Pyx_RefNanny) { __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("event", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -3939,7 +6639,7 @@ if (!__Pyx_RefNanny) { { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "ssh.event")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.event", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "ssh.event", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif @@ -3951,35 +6651,158 @@ if (!__Pyx_RefNanny) { (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif - /* "ssh/event.pyx":1 - * # This file is part of ssh-python. # <<<<<<<<<<<<<< - * # Copyright (C) 2018 Panos Kittenis - * # + /* "ssh/event.pyx":58 + * return -1 + * + * def add_fd(self, sock, short events, callback=None): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(sock) + * cdef c_ssh.ssh_event_callback cb = \ */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_5add_fd, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_add_fd, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_5event_Event, __pyx_n_s_add_fd, __pyx_t_2) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_5event_Event); - /*--- Wrapped vars code ---*/ + /* "ssh/event.pyx":70 + * return rc + * + * def remove_fd(self, socket): # <<<<<<<<<<<<<< + * cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(socket) + * cdef int rc + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_7remove_fd, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_remove_fd, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_5event_Event, __pyx_n_s_remove_fd, __pyx_t_2) < 0) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_5event_Event); + + /* "ssh/event.pyx":79 + * return rc + * + * def add_session(self, Session session): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_9add_session, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_add_session, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_5event_Event, __pyx_n_s_add_session, __pyx_t_2) < 0) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_5event_Event); + + /* "ssh/event.pyx":87 + * return rc + * + * def add_connector(self, Connector connector): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_11add_connector, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_add_connector, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_5event_Event, __pyx_n_s_add_connector, __pyx_t_2) < 0) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_5event_Event); + + /* "ssh/event.pyx":96 + * return handle_error_codes(rc, connector.session._session) + * + * def dopoll(self, int timeout): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_13dopoll, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_dopoll, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_5event_Event, __pyx_n_s_dopoll, __pyx_t_2) < 0) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_5event_Event); + + /* "ssh/event.pyx":102 + * return rc + * + * def remove_session(self, Session session): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_15remove_session, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_remove_session, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_5event_Event, __pyx_n_s_remove_session, __pyx_t_2) < 0) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_5event_Event); + + /* "ssh/event.pyx":110 + * return rc + * + * def remove_connector(self, Connector connector): # <<<<<<<<<<<<<< + * cdef int rc + * with nogil: + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_17remove_connector, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_remove_connector, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_5event_Event, __pyx_n_s_remove_connector, __pyx_t_2) < 0) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_3ssh_5event_Event); + + /* "(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_3ssh_5event_5Event_19__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event___reduce_cython, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_5event_5Event_21__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event___setstate_cython, NULL, __pyx_n_s_ssh_event, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "ssh/event.pyx":1 + * # This file is part of ssh-python. # <<<<<<<<<<<<<< + * # Copyright (C) 2018 Panos Kittenis + * # + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init ssh.event", __pyx_clineno, __pyx_lineno, __pyx_filename); } + #if !CYTHON_USE_MODULE_STATE Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init ssh.event"); } @@ -3993,6 +6816,22 @@ if (!__Pyx_RefNanny) { return; #endif } +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ @@ -4012,6 +6851,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { @@ -4026,10 +6967,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject } #endif +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); @@ -4040,6 +7010,231 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; irecursion_depth; return result; } -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); @@ -4152,9 +7380,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } + #endif if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && @@ -4223,7 +7457,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, return result; } #endif -#endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON @@ -4232,8 +7465,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -4250,10 +7488,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -4265,98 +7508,91 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject } #endif -/* PyObjectCallNoArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} #endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) -#endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) return __Pyx_PyObject_CallMethO(func, NULL); - } } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); -} -#endif - -/* PyCFunctionFastCall */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + 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 - -/* PyObjectCallOneArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); } -#endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (__Pyx_PyFastCFunction_Check(func)) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); + } + #endif } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif } -#endif /* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; @@ -4368,21 +7604,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; - #else + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; - #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); + #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; @@ -4403,31 +7664,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); -} -#endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + #endif } #endif @@ -4438,20 +7675,32 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { - PyObject *local_type, *local_value, *local_tb; + PyObject *local_type = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } + #else local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; + #endif #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) @@ -4473,12 +7722,21 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; + #endif } #else tmp_type = tstate->exc_type; @@ -4505,72 +7763,6 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) return -1; } -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - -/* WriteUnraisableException */ -static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, - CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, - int full_traceback, CYTHON_UNUSED int nogil) { - PyObject *old_exc, *old_val, *old_tb; - PyObject *ctx; - __Pyx_PyThreadState_declare -#ifdef WITH_THREAD - PyGILState_STATE state; - if (nogil) - state = PyGILState_Ensure(); -#ifdef _MSC_VER - else state = (PyGILState_STATE)-1; -#endif -#endif - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); - if (full_traceback) { - Py_XINCREF(old_exc); - Py_XINCREF(old_val); - Py_XINCREF(old_tb); - __Pyx_ErrRestore(old_exc, old_val, old_tb); - PyErr_PrintEx(1); - } - #if PY_MAJOR_VERSION < 3 - ctx = PyString_FromString(name); - #else - ctx = PyUnicode_FromString(name); - #endif - __Pyx_ErrRestore(old_exc, old_val, old_tb); - if (!ctx) { - PyErr_WriteUnraisable(Py_None); - } else { - PyErr_WriteUnraisable(ctx); - Py_DECREF(ctx); - } -#ifdef WITH_THREAD - if (nogil) - PyGILState_Release(state); -#endif -} - /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, @@ -4588,6 +7780,7 @@ static void __Pyx_RaiseDoubleKeywordsError( /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, + PyObject *const *kwvalues, PyObject **argnames[], PyObject *kwds2, PyObject *values[], @@ -4598,13 +7791,54 @@ static int __Pyx_ParseOptionalKeywords( Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; - while (PyDict_Next(kwds, &pos, &key, &value)) { + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; continue; } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { @@ -4612,6 +7846,9 @@ static int __Pyx_ParseOptionalKeywords( if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif break; } name++; @@ -4632,14 +7869,18 @@ static int __Pyx_ParseOptionalKeywords( #endif if (likely(PyUnicode_Check(key))) { while (*name) { - int cmp = (**name == key) ? 0 : + int cmp = ( #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif - PyUnicode_Compare(**name, key); + PyUnicode_Compare(**name, key) + ); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif break; } name++; @@ -4666,6 +7907,8 @@ static int __Pyx_ParseOptionalKeywords( goto invalid_keyword; } } + Py_XDECREF(key); + Py_XDECREF(value); return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); @@ -4675,21 +7918,26 @@ static int __Pyx_ParseOptionalKeywords( "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: - PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else + PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: + Py_XDECREF(key); + Py_XDECREF(value); return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; @@ -4702,17 +7950,21 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); return 0; } /* RaiseException */ #if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); Py_XINCREF(type); if (!value || value == Py_None) value = NULL; @@ -4845,13 +8097,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } PyErr_SetObject(type, value); if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else + #if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { @@ -4859,6 +8107,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); #endif } bad: @@ -4867,66 +8121,437 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } #endif -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + type->tp_print = (printfunc) memb->offset; #endif - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; + changed = 1; + } +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; } + if (changed) + PyType_Modified(type); } - return descr; +#endif + return 0; } #endif -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -#endif + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif /* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif - if (!ob) - goto bad; - if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; @@ -4935,33 +8560,85 @@ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { return -1; } -/* PyObjectGetAttrStrNoError */ -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; + { + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; + } } -#endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { + void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); + if (base_vtable != NULL) { + int j; + PyTypeObject* base = type->tp_base; + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = base->tp_base; + } + } } - return result; + PyErr_Clear(); + free(base_vtables); + return 0; +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; } +#endif /* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { @@ -5027,7 +8704,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); @@ -5043,8 +8720,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } goto __PYX_GOOD; __PYX_BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP @@ -5060,18 +8742,21 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { Py_XDECREF(setstate_cython); return ret; } +#endif /* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; -#ifdef Py_LIMITED_API + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; + PyObject *py_itemsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) @@ -5082,8 +8767,9 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, module_name, class_name); goto bad; } -#ifndef Py_LIMITED_API +#if !CYTHON_COMPILING_IN_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) @@ -5093,53 +8779,1226 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; #endif - if ((size_t)basicsize < size) { + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + module_name, class_name, size, basicsize+itemsize); goto bad; } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; -} + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), #endif - -/* GetVTable */ -static void* __Pyx_GetVtable(PyObject *dict) { - void* ptr; - PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); - if (!ob) - goto bad; -#if PY_VERSION_HEX >= 0x02070000 - ptr = PyCapsule_GetPointer(ob, 0); + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, #else - ptr = PyCObject_AsVoidPtr(ob); + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, #endif - 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; +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } /* PyDictVersioning */ @@ -5170,12 +10029,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -5189,7 +10049,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -5211,6 +10071,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -5289,17 +10150,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -5334,6 +10279,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -5349,7 +10295,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -5396,6 +10342,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -5432,7 +10379,7 @@ static CYTHON_INLINE short __Pyx_PyInt_As_short(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(short) < sizeof(long)) { + if ((sizeof(short) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(short, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -5446,40 +10393,45 @@ static CYTHON_INLINE short __Pyx_PyInt_As_short(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (short) 0; - case 1: __PYX_VERIFY_RETURN_INT(short, digit, digits[0]) - case 2: - if (8 * sizeof(short) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(short) >= 2 * PyLong_SHIFT) { - return (short) (((((short)digits[1]) << PyLong_SHIFT) | (short)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(short, __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(short) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(short) >= 2 * PyLong_SHIFT)) { + return (short) (((((short)digits[1]) << PyLong_SHIFT) | (short)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(short) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(short) >= 3 * PyLong_SHIFT) { - return (short) (((((((short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0])); + break; + case 3: + if ((8 * sizeof(short) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(short) >= 3 * PyLong_SHIFT)) { + return (short) (((((((short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(short) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, 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(short) >= 4 * PyLong_SHIFT) { - return (short) (((((((((short)digits[3]) << PyLong_SHIFT) | (short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0])); + break; + case 4: + if ((8 * sizeof(short) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, 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(short) >= 4 * PyLong_SHIFT)) { + return (short) (((((((((short)digits[3]) << PyLong_SHIFT) | (short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -5492,109 +10444,181 @@ static CYTHON_INLINE short __Pyx_PyInt_As_short(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(short) <= sizeof(unsigned long)) { + if ((sizeof(short) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(short, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(short) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(short) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(short, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (short) 0; - case -1: __PYX_VERIFY_RETURN_INT(short, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(short, digit, +digits[0]) - case -2: - if (8 * sizeof(short) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(short) - 1 > 2 * PyLong_SHIFT) { - return (short) (((short)-1)*(((((short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(short, __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(short) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(short) - 1 > 2 * PyLong_SHIFT)) { + return (short) (((short)-1)*(((((short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(short) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(short) - 1 > 2 * PyLong_SHIFT) { - return (short) ((((((short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + break; + case 2: + if ((8 * sizeof(short) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(short) - 1 > 2 * PyLong_SHIFT)) { + return (short) ((((((short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(short) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(short) - 1 > 3 * PyLong_SHIFT) { - return (short) (((short)-1)*(((((((short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + break; + case -3: + if ((8 * sizeof(short) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(short) - 1 > 3 * PyLong_SHIFT)) { + return (short) (((short)-1)*(((((((short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(short) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(short) - 1 > 3 * PyLong_SHIFT) { - return (short) ((((((((short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + break; + case 3: + if ((8 * sizeof(short) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(short) - 1 > 3 * PyLong_SHIFT)) { + return (short) ((((((((short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(short) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, 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(short) - 1 > 4 * PyLong_SHIFT) { - return (short) (((short)-1)*(((((((((short)digits[3]) << PyLong_SHIFT) | (short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + break; + case -4: + if ((8 * sizeof(short) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, 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(short) - 1 > 4 * PyLong_SHIFT)) { + return (short) (((short)-1)*(((((((((short)digits[3]) << PyLong_SHIFT) | (short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(short) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(short, 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(short) - 1 > 4 * PyLong_SHIFT) { - return (short) ((((((((((short)digits[3]) << PyLong_SHIFT) | (short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + break; + case 4: + if ((8 * sizeof(short) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(short, 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(short) - 1 > 4 * PyLong_SHIFT)) { + return (short) ((((((((((short)digits[3]) << PyLong_SHIFT) | (short)digits[2]) << PyLong_SHIFT) | (short)digits[1]) << PyLong_SHIFT) | (short)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(short) <= sizeof(long)) { + if ((sizeof(short) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(short, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(short) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(short) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(short, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else short val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (short) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (short) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (short) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (short) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (short) 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(short) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((short) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(short) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((short) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((short) 1) << (sizeof(short) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (short) -1; } } else { @@ -5628,7 +10652,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -5642,40 +10666,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -5688,109 +10717,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -5844,11 +10945,53 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__18); + } + return name; +} +#endif + /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC @@ -5882,8 +11025,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -5900,7 +11069,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -5914,40 +11083,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -5960,109 +11134,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -6087,7 +11333,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -6108,6 +11354,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -6132,11 +11394,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -6184,47 +11446,56 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionImport */ -#ifndef __PYX_HAVE_RT_ImportFunction -#define __PYX_HAVE_RT_ImportFunction -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { +#ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { @@ -6241,7 +11512,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** PyModule_GetName(module), funcname); goto bad; } -#if PY_VERSION_HEX >= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", @@ -6249,21 +11519,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); -#else - {const char *desc, *s1, *s2; - desc = (const char *)PyCObject_GetDesc(cobj); - if (!desc) - goto bad; - s1 = desc; s2 = sig; - while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } - if (*s1 != *s2) { - PyErr_Format(PyExc_TypeError, - "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", - PyModule_GetName(module), funcname, sig, desc); - goto bad; - } - tmp.p = PyCObject_AsVoidPtr(cobj);} -#endif *f = tmp.fp; if (!(*f)) goto bad; @@ -6276,9 +11531,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** #endif /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -6286,30 +11563,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -6364,7 +11645,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -6393,22 +11674,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -6474,13 +11759,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -6548,4 +11831,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/exceptions.c b/ssh/exceptions.c index adc1060f..6987cf70 100644 --- a/ssh/exceptions.c +++ b/ssh/exceptions.c @@ -1,22 +1,69 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.exceptions", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/exceptions.pyx" + ] + }, + "module_name": "ssh.exceptions" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +82,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +90,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +127,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +147,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +275,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +304,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +315,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +338,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +365,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +389,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +473,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +497,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +514,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +576,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +611,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +763,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +780,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else -#define __Pyx_PyFastCFunction_Check(func) 0 + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +870,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +916,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +950,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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)) + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1044,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1059,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1101,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1118,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1165,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1185,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1225,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -789,9 +1297,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -809,9 +1318,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -819,13 +1328,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -849,8 +1352,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -871,7 +1420,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -901,6 +1450,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -936,24 +1486,26 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "ssh/exceptions.pyx", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -962,11 +1514,11 @@ static const char *__pyx_f[] = { #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -976,28 +1528,40 @@ static const char *__pyx_f[] = { #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ } -#else + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } +#else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1008,6 +1572,10 @@ static const char *__pyx_f[] = { #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);\ @@ -1019,8 +1587,110 @@ static const char *__pyx_f[] = { #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) -/* CalculateMetaclass.proto */ -static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#endif +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS @@ -1029,15 +1699,37 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* Py3UpdateBases.proto */ +static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* 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 + /* Py3ClassCreate.proto */ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc); static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1066,18 +1758,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) @@ -1085,42 +1777,6 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) @@ -1129,6 +1785,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1142,13 +1799,27 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif @@ -1164,44 +1835,59 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ -/* Module declarations from 'ssh.exceptions' */ +/* Module declarations from "ssh.exceptions" */ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.exceptions" extern int __pyx_module_is_main_ssh__exceptions; int __pyx_module_is_main_ssh__exceptions = 0; -/* Implementation of 'ssh.exceptions' */ +/* Implementation of "ssh.exceptions" */ +/* #### Code section: global_var ### */ +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = "?"; static const char __pyx_k_EOF[] = "EOF"; static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_super[] = "super"; static const char __pyx_k_module[] = "__module__"; static const char __pyx_k_prepare[] = "__prepare__"; static const char __pyx_k_MACError[] = "MACError"; static const char __pyx_k_SSHError[] = "SSHError"; static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_set_name[] = "__set_name__"; static const char __pyx_k_SFTPError[] = "SFTPError"; static const char __pyx_k_metaclass[] = "__metaclass__"; static const char __pyx_k_OtherError[] = "OtherError"; static const char __pyx_k_GSSAPIError[] = "GSSAPIError"; static const char __pyx_k_OptionError[] = "OptionError"; +static const char __pyx_k_mro_entries[] = "__mro_entries__"; static const char __pyx_k_BaseSSHError[] = "BaseSSHError"; static const char __pyx_k_Disconnected[] = "Disconnected"; static const char __pyx_k_ChannelClosed[] = "ChannelClosed"; @@ -1209,6 +1895,7 @@ static const char __pyx_k_ConnectFailed[] = "ConnectFailed"; static const char __pyx_k_InvalidAPIUse[] = "InvalidAPIUse"; static const char __pyx_k_ProtocolError[] = "ProtocolError"; static const char __pyx_k_UnImplemented[] = "UnImplemented"; +static const char __pyx_k_init_subclass[] = "__init_subclass__"; static const char __pyx_k_ConnectionLost[] = "ConnectionLost"; static const char __pyx_k_GSSAPIErrorTok[] = "GSSAPIErrorTok"; static const char __pyx_k_KeyExportError[] = "KeyExportError"; @@ -1269,125 +1956,485 @@ static const char __pyx_k_Raised_on_partial_authentication[] = "Raised on partia static const char __pyx_k_Raised_on_protocol_version_not_s[] = "Raised on protocol version not supported"; static const char __pyx_k_Raised_on_resource_shortage_erro[] = "Raised on resource shortage errors"; static const char __pyx_k_Raised_on_too_many_connection_er[] = "Raised on too many connection errors"; -static PyObject *__pyx_n_s_AdministrativelyProhibited; -static PyObject *__pyx_n_s_AuthenticationDenied; -static PyObject *__pyx_n_s_AuthenticationError; -static PyObject *__pyx_n_s_AuthenticationPartial; -static PyObject *__pyx_n_s_BaseSSHError; -static PyObject *__pyx_kp_s_Base_class_for_all_errors_produc; -static PyObject *__pyx_n_s_ChannelClosed; -static PyObject *__pyx_n_s_ChannelOpenFailure; -static PyObject *__pyx_n_s_CompressionError; -static PyObject *__pyx_n_s_ConnectFailed; -static PyObject *__pyx_n_s_ConnectionLost; -static PyObject *__pyx_n_s_Disconnected; -static PyObject *__pyx_n_s_EOF; -static PyObject *__pyx_n_s_GSSAPIError; -static PyObject *__pyx_n_s_GSSAPIErrorTok; -static PyObject *__pyx_n_s_HostAuthenticationFailed; -static PyObject *__pyx_n_s_HostKeyNotVerifiable; -static PyObject *__pyx_n_s_HostNotAllowedToConnect; -static PyObject *__pyx_n_s_InvalidAPIUse; -static PyObject *__pyx_n_s_KeyExchangeFailed; -static PyObject *__pyx_n_s_KeyExportError; -static PyObject *__pyx_n_s_KeyGenerationError; -static PyObject *__pyx_n_s_KeyImportError; -static PyObject *__pyx_n_s_MACError; -static PyObject *__pyx_n_s_OptionError; -static PyObject *__pyx_n_s_OtherError; -static PyObject *__pyx_n_s_ProtocolError; -static PyObject *__pyx_n_s_ProtocolVersionNotSupport; -static PyObject *__pyx_kp_s_Raised_on_EOF_from_remote_channe; -static PyObject *__pyx_kp_s_Raised_on_GSS_API_errors; -static PyObject *__pyx_kp_s_Raised_on_GSS_API_token_errors; -static PyObject *__pyx_kp_s_Raised_on_MAC_errors; -static PyObject *__pyx_kp_s_Raised_on_SFTP_errors; -static PyObject *__pyx_kp_s_Raised_on_SFTP_handle_errors; -static PyObject *__pyx_kp_s_Raised_on_SSH_channel_open_failu; -static PyObject *__pyx_kp_s_Raised_on_SSH_request_failures; -static PyObject *__pyx_kp_s_Raised_on_administratively_prohi; -static PyObject *__pyx_kp_s_Raised_on_authentication_denied; -static PyObject *__pyx_kp_s_Raised_on_compression_errors; -static PyObject *__pyx_kp_s_Raised_on_connect_failure; -static PyObject *__pyx_kp_s_Raised_on_connection_lost; -static PyObject *__pyx_kp_s_Raised_on_disconnection_errors; -static PyObject *__pyx_kp_s_Raised_on_errors_exporting_key; -static PyObject *__pyx_kp_s_Raised_on_errors_generating_key; -static PyObject *__pyx_kp_s_Raised_on_errors_getting_setting; -static PyObject *__pyx_kp_s_Raised_on_errors_importing_key; -static PyObject *__pyx_kp_s_Raised_on_errors_returned_by_lib; -static PyObject *__pyx_kp_s_Raised_on_fatal_errors_authentic; -static PyObject *__pyx_kp_s_Raised_on_host_authentication_fa; -static PyObject *__pyx_kp_s_Raised_on_host_key_not_verifiabl; -static PyObject *__pyx_kp_s_Raised_on_host_not_allowed_to_co; -static PyObject *__pyx_kp_s_Raised_on_invalid_uses_of_the_AP; -static PyObject *__pyx_kp_s_Raised_on_key_exchange_failures; -static PyObject *__pyx_kp_s_Raised_on_operations_on_closed_c; -static PyObject *__pyx_kp_s_Raised_on_other_non_specific_fat; -static PyObject *__pyx_kp_s_Raised_on_partial_authentication; -static PyObject *__pyx_kp_s_Raised_on_protocol_errors; -static PyObject *__pyx_kp_s_Raised_on_protocol_version_not_s; -static PyObject *__pyx_kp_s_Raised_on_resource_shortage_erro; -static PyObject *__pyx_kp_s_Raised_on_service_not_available; -static PyObject *__pyx_kp_s_Raised_on_too_many_connection_er; -static PyObject *__pyx_kp_s_Raised_on_unimplemented_errors; -static PyObject *__pyx_kp_s_Raised_on_unknown_channel_type; -static PyObject *__pyx_n_s_RequestFailure; -static PyObject *__pyx_n_s_ResourceShortage; -static PyObject *__pyx_n_s_SFTPError; -static PyObject *__pyx_n_s_SFTPHandleError; -static PyObject *__pyx_n_s_SSHError; -static PyObject *__pyx_n_s_ServiceNotAvailable; -static PyObject *__pyx_n_s_TooManyConnections; -static PyObject *__pyx_n_s_UnImplemented; -static PyObject *__pyx_n_s_UnknownChannelType; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_doc; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_metaclass; -static PyObject *__pyx_n_s_module; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_prepare; -static PyObject *__pyx_n_s_qualname; -static PyObject *__pyx_n_s_ssh_exceptions; -static PyObject *__pyx_n_s_test; -/* Late includes */ - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; +/* #### Code section: decls ### */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyObject *__pyx_n_s_; + PyObject *__pyx_n_s_AdministrativelyProhibited; + PyObject *__pyx_n_s_AuthenticationDenied; + PyObject *__pyx_n_s_AuthenticationError; + PyObject *__pyx_n_s_AuthenticationPartial; + PyObject *__pyx_n_s_BaseSSHError; + PyObject *__pyx_kp_s_Base_class_for_all_errors_produc; + PyObject *__pyx_n_s_ChannelClosed; + PyObject *__pyx_n_s_ChannelOpenFailure; + PyObject *__pyx_n_s_CompressionError; + PyObject *__pyx_n_s_ConnectFailed; + PyObject *__pyx_n_s_ConnectionLost; + PyObject *__pyx_n_s_Disconnected; + PyObject *__pyx_n_s_EOF; + PyObject *__pyx_n_s_GSSAPIError; + PyObject *__pyx_n_s_GSSAPIErrorTok; + PyObject *__pyx_n_s_HostAuthenticationFailed; + PyObject *__pyx_n_s_HostKeyNotVerifiable; + PyObject *__pyx_n_s_HostNotAllowedToConnect; + PyObject *__pyx_n_s_InvalidAPIUse; + PyObject *__pyx_n_s_KeyExchangeFailed; + PyObject *__pyx_n_s_KeyExportError; + PyObject *__pyx_n_s_KeyGenerationError; + PyObject *__pyx_n_s_KeyImportError; + PyObject *__pyx_n_s_MACError; + PyObject *__pyx_n_s_OptionError; + PyObject *__pyx_n_s_OtherError; + PyObject *__pyx_n_s_ProtocolError; + PyObject *__pyx_n_s_ProtocolVersionNotSupport; + PyObject *__pyx_kp_s_Raised_on_EOF_from_remote_channe; + PyObject *__pyx_kp_s_Raised_on_GSS_API_errors; + PyObject *__pyx_kp_s_Raised_on_GSS_API_token_errors; + PyObject *__pyx_kp_s_Raised_on_MAC_errors; + PyObject *__pyx_kp_s_Raised_on_SFTP_errors; + PyObject *__pyx_kp_s_Raised_on_SFTP_handle_errors; + PyObject *__pyx_kp_s_Raised_on_SSH_channel_open_failu; + PyObject *__pyx_kp_s_Raised_on_SSH_request_failures; + PyObject *__pyx_kp_s_Raised_on_administratively_prohi; + PyObject *__pyx_kp_s_Raised_on_authentication_denied; + PyObject *__pyx_kp_s_Raised_on_compression_errors; + PyObject *__pyx_kp_s_Raised_on_connect_failure; + PyObject *__pyx_kp_s_Raised_on_connection_lost; + PyObject *__pyx_kp_s_Raised_on_disconnection_errors; + PyObject *__pyx_kp_s_Raised_on_errors_exporting_key; + PyObject *__pyx_kp_s_Raised_on_errors_generating_key; + PyObject *__pyx_kp_s_Raised_on_errors_getting_setting; + PyObject *__pyx_kp_s_Raised_on_errors_importing_key; + PyObject *__pyx_kp_s_Raised_on_errors_returned_by_lib; + PyObject *__pyx_kp_s_Raised_on_fatal_errors_authentic; + PyObject *__pyx_kp_s_Raised_on_host_authentication_fa; + PyObject *__pyx_kp_s_Raised_on_host_key_not_verifiabl; + PyObject *__pyx_kp_s_Raised_on_host_not_allowed_to_co; + PyObject *__pyx_kp_s_Raised_on_invalid_uses_of_the_AP; + PyObject *__pyx_kp_s_Raised_on_key_exchange_failures; + PyObject *__pyx_kp_s_Raised_on_operations_on_closed_c; + PyObject *__pyx_kp_s_Raised_on_other_non_specific_fat; + PyObject *__pyx_kp_s_Raised_on_partial_authentication; + PyObject *__pyx_kp_s_Raised_on_protocol_errors; + PyObject *__pyx_kp_s_Raised_on_protocol_version_not_s; + PyObject *__pyx_kp_s_Raised_on_resource_shortage_erro; + PyObject *__pyx_kp_s_Raised_on_service_not_available; + PyObject *__pyx_kp_s_Raised_on_too_many_connection_er; + PyObject *__pyx_kp_s_Raised_on_unimplemented_errors; + PyObject *__pyx_kp_s_Raised_on_unknown_channel_type; + PyObject *__pyx_n_s_RequestFailure; + PyObject *__pyx_n_s_ResourceShortage; + PyObject *__pyx_n_s_SFTPError; + PyObject *__pyx_n_s_SFTPHandleError; + PyObject *__pyx_n_s_SSHError; + PyObject *__pyx_n_s_ServiceNotAvailable; + PyObject *__pyx_n_s_TooManyConnections; + PyObject *__pyx_n_s_UnImplemented; + PyObject *__pyx_n_s_UnknownChannelType; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_n_s_doc; + PyObject *__pyx_n_s_init_subclass; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_metaclass; + PyObject *__pyx_n_s_module; + PyObject *__pyx_n_s_mro_entries; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_prepare; + PyObject *__pyx_n_s_qualname; + PyObject *__pyx_n_s_set_name; + PyObject *__pyx_n_s_ssh_exceptions; + PyObject *__pyx_n_s_super; + PyObject *__pyx_n_s_test; +} __pyx_mstate; -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_exceptions(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_exceptions}, - {0, NULL} -}; +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; #endif -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "exceptions", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; + Py_CLEAR(clear_module_state->__pyx_n_s_); + Py_CLEAR(clear_module_state->__pyx_n_s_AdministrativelyProhibited); + Py_CLEAR(clear_module_state->__pyx_n_s_AuthenticationDenied); + Py_CLEAR(clear_module_state->__pyx_n_s_AuthenticationError); + Py_CLEAR(clear_module_state->__pyx_n_s_AuthenticationPartial); + Py_CLEAR(clear_module_state->__pyx_n_s_BaseSSHError); + Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_all_errors_produc); + Py_CLEAR(clear_module_state->__pyx_n_s_ChannelClosed); + Py_CLEAR(clear_module_state->__pyx_n_s_ChannelOpenFailure); + Py_CLEAR(clear_module_state->__pyx_n_s_CompressionError); + Py_CLEAR(clear_module_state->__pyx_n_s_ConnectFailed); + Py_CLEAR(clear_module_state->__pyx_n_s_ConnectionLost); + Py_CLEAR(clear_module_state->__pyx_n_s_Disconnected); + Py_CLEAR(clear_module_state->__pyx_n_s_EOF); + Py_CLEAR(clear_module_state->__pyx_n_s_GSSAPIError); + Py_CLEAR(clear_module_state->__pyx_n_s_GSSAPIErrorTok); + Py_CLEAR(clear_module_state->__pyx_n_s_HostAuthenticationFailed); + Py_CLEAR(clear_module_state->__pyx_n_s_HostKeyNotVerifiable); + Py_CLEAR(clear_module_state->__pyx_n_s_HostNotAllowedToConnect); + Py_CLEAR(clear_module_state->__pyx_n_s_InvalidAPIUse); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyExchangeFailed); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyExportError); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyGenerationError); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyImportError); + Py_CLEAR(clear_module_state->__pyx_n_s_MACError); + Py_CLEAR(clear_module_state->__pyx_n_s_OptionError); + Py_CLEAR(clear_module_state->__pyx_n_s_OtherError); + Py_CLEAR(clear_module_state->__pyx_n_s_ProtocolError); + Py_CLEAR(clear_module_state->__pyx_n_s_ProtocolVersionNotSupport); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_EOF_from_remote_channe); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_GSS_API_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_GSS_API_token_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_MAC_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SFTP_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SFTP_handle_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SSH_channel_open_failu); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SSH_request_failures); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_administratively_prohi); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_authentication_denied); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_compression_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_connect_failure); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_connection_lost); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_disconnection_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_exporting_key); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_generating_key); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_getting_setting); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_importing_key); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_returned_by_lib); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_fatal_errors_authentic); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_host_authentication_fa); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_host_key_not_verifiabl); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_host_not_allowed_to_co); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_invalid_uses_of_the_AP); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_key_exchange_failures); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_operations_on_closed_c); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_other_non_specific_fat); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_partial_authentication); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_protocol_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_protocol_version_not_s); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_resource_shortage_erro); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_service_not_available); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_too_many_connection_er); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_unimplemented_errors); + Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_unknown_channel_type); + Py_CLEAR(clear_module_state->__pyx_n_s_RequestFailure); + Py_CLEAR(clear_module_state->__pyx_n_s_ResourceShortage); + Py_CLEAR(clear_module_state->__pyx_n_s_SFTPError); + Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandleError); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHError); + Py_CLEAR(clear_module_state->__pyx_n_s_ServiceNotAvailable); + Py_CLEAR(clear_module_state->__pyx_n_s_TooManyConnections); + Py_CLEAR(clear_module_state->__pyx_n_s_UnImplemented); + Py_CLEAR(clear_module_state->__pyx_n_s_UnknownChannelType); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_doc); + Py_CLEAR(clear_module_state->__pyx_n_s_init_subclass); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_metaclass); + Py_CLEAR(clear_module_state->__pyx_n_s_module); + Py_CLEAR(clear_module_state->__pyx_n_s_mro_entries); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_prepare); + Py_CLEAR(clear_module_state->__pyx_n_s_qualname); + Py_CLEAR(clear_module_state->__pyx_n_s_set_name); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_exceptions); + Py_CLEAR(clear_module_state->__pyx_n_s_super); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_n_s_); + Py_VISIT(traverse_module_state->__pyx_n_s_AdministrativelyProhibited); + Py_VISIT(traverse_module_state->__pyx_n_s_AuthenticationDenied); + Py_VISIT(traverse_module_state->__pyx_n_s_AuthenticationError); + Py_VISIT(traverse_module_state->__pyx_n_s_AuthenticationPartial); + Py_VISIT(traverse_module_state->__pyx_n_s_BaseSSHError); + Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_all_errors_produc); + Py_VISIT(traverse_module_state->__pyx_n_s_ChannelClosed); + Py_VISIT(traverse_module_state->__pyx_n_s_ChannelOpenFailure); + Py_VISIT(traverse_module_state->__pyx_n_s_CompressionError); + Py_VISIT(traverse_module_state->__pyx_n_s_ConnectFailed); + Py_VISIT(traverse_module_state->__pyx_n_s_ConnectionLost); + Py_VISIT(traverse_module_state->__pyx_n_s_Disconnected); + Py_VISIT(traverse_module_state->__pyx_n_s_EOF); + Py_VISIT(traverse_module_state->__pyx_n_s_GSSAPIError); + Py_VISIT(traverse_module_state->__pyx_n_s_GSSAPIErrorTok); + Py_VISIT(traverse_module_state->__pyx_n_s_HostAuthenticationFailed); + Py_VISIT(traverse_module_state->__pyx_n_s_HostKeyNotVerifiable); + Py_VISIT(traverse_module_state->__pyx_n_s_HostNotAllowedToConnect); + Py_VISIT(traverse_module_state->__pyx_n_s_InvalidAPIUse); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyExchangeFailed); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyExportError); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyGenerationError); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyImportError); + Py_VISIT(traverse_module_state->__pyx_n_s_MACError); + Py_VISIT(traverse_module_state->__pyx_n_s_OptionError); + Py_VISIT(traverse_module_state->__pyx_n_s_OtherError); + Py_VISIT(traverse_module_state->__pyx_n_s_ProtocolError); + Py_VISIT(traverse_module_state->__pyx_n_s_ProtocolVersionNotSupport); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_EOF_from_remote_channe); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_GSS_API_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_GSS_API_token_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_MAC_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SFTP_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SFTP_handle_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SSH_channel_open_failu); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SSH_request_failures); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_administratively_prohi); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_authentication_denied); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_compression_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_connect_failure); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_connection_lost); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_disconnection_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_exporting_key); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_generating_key); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_getting_setting); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_importing_key); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_returned_by_lib); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_fatal_errors_authentic); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_host_authentication_fa); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_host_key_not_verifiabl); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_host_not_allowed_to_co); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_invalid_uses_of_the_AP); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_key_exchange_failures); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_operations_on_closed_c); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_other_non_specific_fat); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_partial_authentication); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_protocol_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_protocol_version_not_s); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_resource_shortage_erro); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_service_not_available); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_too_many_connection_er); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_unimplemented_errors); + Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_unknown_channel_type); + Py_VISIT(traverse_module_state->__pyx_n_s_RequestFailure); + Py_VISIT(traverse_module_state->__pyx_n_s_ResourceShortage); + Py_VISIT(traverse_module_state->__pyx_n_s_SFTPError); + Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandleError); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHError); + Py_VISIT(traverse_module_state->__pyx_n_s_ServiceNotAvailable); + Py_VISIT(traverse_module_state->__pyx_n_s_TooManyConnections); + Py_VISIT(traverse_module_state->__pyx_n_s_UnImplemented); + Py_VISIT(traverse_module_state->__pyx_n_s_UnknownChannelType); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_doc); + Py_VISIT(traverse_module_state->__pyx_n_s_init_subclass); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_metaclass); + Py_VISIT(traverse_module_state->__pyx_n_s_module); + Py_VISIT(traverse_module_state->__pyx_n_s_mro_entries); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_prepare); + Py_VISIT(traverse_module_state->__pyx_n_s_qualname); + Py_VISIT(traverse_module_state->__pyx_n_s_set_name); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_exceptions); + Py_VISIT(traverse_module_state->__pyx_n_s_super); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + return 0; +} #endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_n_s_ __pyx_mstate_global->__pyx_n_s_ +#define __pyx_n_s_AdministrativelyProhibited __pyx_mstate_global->__pyx_n_s_AdministrativelyProhibited +#define __pyx_n_s_AuthenticationDenied __pyx_mstate_global->__pyx_n_s_AuthenticationDenied +#define __pyx_n_s_AuthenticationError __pyx_mstate_global->__pyx_n_s_AuthenticationError +#define __pyx_n_s_AuthenticationPartial __pyx_mstate_global->__pyx_n_s_AuthenticationPartial +#define __pyx_n_s_BaseSSHError __pyx_mstate_global->__pyx_n_s_BaseSSHError +#define __pyx_kp_s_Base_class_for_all_errors_produc __pyx_mstate_global->__pyx_kp_s_Base_class_for_all_errors_produc +#define __pyx_n_s_ChannelClosed __pyx_mstate_global->__pyx_n_s_ChannelClosed +#define __pyx_n_s_ChannelOpenFailure __pyx_mstate_global->__pyx_n_s_ChannelOpenFailure +#define __pyx_n_s_CompressionError __pyx_mstate_global->__pyx_n_s_CompressionError +#define __pyx_n_s_ConnectFailed __pyx_mstate_global->__pyx_n_s_ConnectFailed +#define __pyx_n_s_ConnectionLost __pyx_mstate_global->__pyx_n_s_ConnectionLost +#define __pyx_n_s_Disconnected __pyx_mstate_global->__pyx_n_s_Disconnected +#define __pyx_n_s_EOF __pyx_mstate_global->__pyx_n_s_EOF +#define __pyx_n_s_GSSAPIError __pyx_mstate_global->__pyx_n_s_GSSAPIError +#define __pyx_n_s_GSSAPIErrorTok __pyx_mstate_global->__pyx_n_s_GSSAPIErrorTok +#define __pyx_n_s_HostAuthenticationFailed __pyx_mstate_global->__pyx_n_s_HostAuthenticationFailed +#define __pyx_n_s_HostKeyNotVerifiable __pyx_mstate_global->__pyx_n_s_HostKeyNotVerifiable +#define __pyx_n_s_HostNotAllowedToConnect __pyx_mstate_global->__pyx_n_s_HostNotAllowedToConnect +#define __pyx_n_s_InvalidAPIUse __pyx_mstate_global->__pyx_n_s_InvalidAPIUse +#define __pyx_n_s_KeyExchangeFailed __pyx_mstate_global->__pyx_n_s_KeyExchangeFailed +#define __pyx_n_s_KeyExportError __pyx_mstate_global->__pyx_n_s_KeyExportError +#define __pyx_n_s_KeyGenerationError __pyx_mstate_global->__pyx_n_s_KeyGenerationError +#define __pyx_n_s_KeyImportError __pyx_mstate_global->__pyx_n_s_KeyImportError +#define __pyx_n_s_MACError __pyx_mstate_global->__pyx_n_s_MACError +#define __pyx_n_s_OptionError __pyx_mstate_global->__pyx_n_s_OptionError +#define __pyx_n_s_OtherError __pyx_mstate_global->__pyx_n_s_OtherError +#define __pyx_n_s_ProtocolError __pyx_mstate_global->__pyx_n_s_ProtocolError +#define __pyx_n_s_ProtocolVersionNotSupport __pyx_mstate_global->__pyx_n_s_ProtocolVersionNotSupport +#define __pyx_kp_s_Raised_on_EOF_from_remote_channe __pyx_mstate_global->__pyx_kp_s_Raised_on_EOF_from_remote_channe +#define __pyx_kp_s_Raised_on_GSS_API_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_GSS_API_errors +#define __pyx_kp_s_Raised_on_GSS_API_token_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_GSS_API_token_errors +#define __pyx_kp_s_Raised_on_MAC_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_MAC_errors +#define __pyx_kp_s_Raised_on_SFTP_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_SFTP_errors +#define __pyx_kp_s_Raised_on_SFTP_handle_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_SFTP_handle_errors +#define __pyx_kp_s_Raised_on_SSH_channel_open_failu __pyx_mstate_global->__pyx_kp_s_Raised_on_SSH_channel_open_failu +#define __pyx_kp_s_Raised_on_SSH_request_failures __pyx_mstate_global->__pyx_kp_s_Raised_on_SSH_request_failures +#define __pyx_kp_s_Raised_on_administratively_prohi __pyx_mstate_global->__pyx_kp_s_Raised_on_administratively_prohi +#define __pyx_kp_s_Raised_on_authentication_denied __pyx_mstate_global->__pyx_kp_s_Raised_on_authentication_denied +#define __pyx_kp_s_Raised_on_compression_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_compression_errors +#define __pyx_kp_s_Raised_on_connect_failure __pyx_mstate_global->__pyx_kp_s_Raised_on_connect_failure +#define __pyx_kp_s_Raised_on_connection_lost __pyx_mstate_global->__pyx_kp_s_Raised_on_connection_lost +#define __pyx_kp_s_Raised_on_disconnection_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_disconnection_errors +#define __pyx_kp_s_Raised_on_errors_exporting_key __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_exporting_key +#define __pyx_kp_s_Raised_on_errors_generating_key __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_generating_key +#define __pyx_kp_s_Raised_on_errors_getting_setting __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_getting_setting +#define __pyx_kp_s_Raised_on_errors_importing_key __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_importing_key +#define __pyx_kp_s_Raised_on_errors_returned_by_lib __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_returned_by_lib +#define __pyx_kp_s_Raised_on_fatal_errors_authentic __pyx_mstate_global->__pyx_kp_s_Raised_on_fatal_errors_authentic +#define __pyx_kp_s_Raised_on_host_authentication_fa __pyx_mstate_global->__pyx_kp_s_Raised_on_host_authentication_fa +#define __pyx_kp_s_Raised_on_host_key_not_verifiabl __pyx_mstate_global->__pyx_kp_s_Raised_on_host_key_not_verifiabl +#define __pyx_kp_s_Raised_on_host_not_allowed_to_co __pyx_mstate_global->__pyx_kp_s_Raised_on_host_not_allowed_to_co +#define __pyx_kp_s_Raised_on_invalid_uses_of_the_AP __pyx_mstate_global->__pyx_kp_s_Raised_on_invalid_uses_of_the_AP +#define __pyx_kp_s_Raised_on_key_exchange_failures __pyx_mstate_global->__pyx_kp_s_Raised_on_key_exchange_failures +#define __pyx_kp_s_Raised_on_operations_on_closed_c __pyx_mstate_global->__pyx_kp_s_Raised_on_operations_on_closed_c +#define __pyx_kp_s_Raised_on_other_non_specific_fat __pyx_mstate_global->__pyx_kp_s_Raised_on_other_non_specific_fat +#define __pyx_kp_s_Raised_on_partial_authentication __pyx_mstate_global->__pyx_kp_s_Raised_on_partial_authentication +#define __pyx_kp_s_Raised_on_protocol_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_protocol_errors +#define __pyx_kp_s_Raised_on_protocol_version_not_s __pyx_mstate_global->__pyx_kp_s_Raised_on_protocol_version_not_s +#define __pyx_kp_s_Raised_on_resource_shortage_erro __pyx_mstate_global->__pyx_kp_s_Raised_on_resource_shortage_erro +#define __pyx_kp_s_Raised_on_service_not_available __pyx_mstate_global->__pyx_kp_s_Raised_on_service_not_available +#define __pyx_kp_s_Raised_on_too_many_connection_er __pyx_mstate_global->__pyx_kp_s_Raised_on_too_many_connection_er +#define __pyx_kp_s_Raised_on_unimplemented_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_unimplemented_errors +#define __pyx_kp_s_Raised_on_unknown_channel_type __pyx_mstate_global->__pyx_kp_s_Raised_on_unknown_channel_type +#define __pyx_n_s_RequestFailure __pyx_mstate_global->__pyx_n_s_RequestFailure +#define __pyx_n_s_ResourceShortage __pyx_mstate_global->__pyx_n_s_ResourceShortage +#define __pyx_n_s_SFTPError __pyx_mstate_global->__pyx_n_s_SFTPError +#define __pyx_n_s_SFTPHandleError __pyx_mstate_global->__pyx_n_s_SFTPHandleError +#define __pyx_n_s_SSHError __pyx_mstate_global->__pyx_n_s_SSHError +#define __pyx_n_s_ServiceNotAvailable __pyx_mstate_global->__pyx_n_s_ServiceNotAvailable +#define __pyx_n_s_TooManyConnections __pyx_mstate_global->__pyx_n_s_TooManyConnections +#define __pyx_n_s_UnImplemented __pyx_mstate_global->__pyx_n_s_UnImplemented +#define __pyx_n_s_UnknownChannelType __pyx_mstate_global->__pyx_n_s_UnknownChannelType +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_n_s_doc __pyx_mstate_global->__pyx_n_s_doc +#define __pyx_n_s_init_subclass __pyx_mstate_global->__pyx_n_s_init_subclass +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_metaclass __pyx_mstate_global->__pyx_n_s_metaclass +#define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module +#define __pyx_n_s_mro_entries __pyx_mstate_global->__pyx_n_s_mro_entries +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_prepare __pyx_mstate_global->__pyx_n_s_prepare +#define __pyx_n_s_qualname __pyx_mstate_global->__pyx_n_s_qualname +#define __pyx_n_s_set_name __pyx_mstate_global->__pyx_n_s_set_name +#define __pyx_n_s_ssh_exceptions __pyx_mstate_global->__pyx_n_s_ssh_exceptions +#define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +/* #### Code section: module_code ### */ + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -1397,95 +2444,107 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif +/* #### Code section: pystring_table ### */ -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_AdministrativelyProhibited, __pyx_k_AdministrativelyProhibited, sizeof(__pyx_k_AdministrativelyProhibited), 0, 0, 1, 1}, - {&__pyx_n_s_AuthenticationDenied, __pyx_k_AuthenticationDenied, sizeof(__pyx_k_AuthenticationDenied), 0, 0, 1, 1}, - {&__pyx_n_s_AuthenticationError, __pyx_k_AuthenticationError, sizeof(__pyx_k_AuthenticationError), 0, 0, 1, 1}, - {&__pyx_n_s_AuthenticationPartial, __pyx_k_AuthenticationPartial, sizeof(__pyx_k_AuthenticationPartial), 0, 0, 1, 1}, - {&__pyx_n_s_BaseSSHError, __pyx_k_BaseSSHError, sizeof(__pyx_k_BaseSSHError), 0, 0, 1, 1}, - {&__pyx_kp_s_Base_class_for_all_errors_produc, __pyx_k_Base_class_for_all_errors_produc, sizeof(__pyx_k_Base_class_for_all_errors_produc), 0, 0, 1, 0}, - {&__pyx_n_s_ChannelClosed, __pyx_k_ChannelClosed, sizeof(__pyx_k_ChannelClosed), 0, 0, 1, 1}, - {&__pyx_n_s_ChannelOpenFailure, __pyx_k_ChannelOpenFailure, sizeof(__pyx_k_ChannelOpenFailure), 0, 0, 1, 1}, - {&__pyx_n_s_CompressionError, __pyx_k_CompressionError, sizeof(__pyx_k_CompressionError), 0, 0, 1, 1}, - {&__pyx_n_s_ConnectFailed, __pyx_k_ConnectFailed, sizeof(__pyx_k_ConnectFailed), 0, 0, 1, 1}, - {&__pyx_n_s_ConnectionLost, __pyx_k_ConnectionLost, sizeof(__pyx_k_ConnectionLost), 0, 0, 1, 1}, - {&__pyx_n_s_Disconnected, __pyx_k_Disconnected, sizeof(__pyx_k_Disconnected), 0, 0, 1, 1}, - {&__pyx_n_s_EOF, __pyx_k_EOF, sizeof(__pyx_k_EOF), 0, 0, 1, 1}, - {&__pyx_n_s_GSSAPIError, __pyx_k_GSSAPIError, sizeof(__pyx_k_GSSAPIError), 0, 0, 1, 1}, - {&__pyx_n_s_GSSAPIErrorTok, __pyx_k_GSSAPIErrorTok, sizeof(__pyx_k_GSSAPIErrorTok), 0, 0, 1, 1}, - {&__pyx_n_s_HostAuthenticationFailed, __pyx_k_HostAuthenticationFailed, sizeof(__pyx_k_HostAuthenticationFailed), 0, 0, 1, 1}, - {&__pyx_n_s_HostKeyNotVerifiable, __pyx_k_HostKeyNotVerifiable, sizeof(__pyx_k_HostKeyNotVerifiable), 0, 0, 1, 1}, - {&__pyx_n_s_HostNotAllowedToConnect, __pyx_k_HostNotAllowedToConnect, sizeof(__pyx_k_HostNotAllowedToConnect), 0, 0, 1, 1}, - {&__pyx_n_s_InvalidAPIUse, __pyx_k_InvalidAPIUse, sizeof(__pyx_k_InvalidAPIUse), 0, 0, 1, 1}, - {&__pyx_n_s_KeyExchangeFailed, __pyx_k_KeyExchangeFailed, sizeof(__pyx_k_KeyExchangeFailed), 0, 0, 1, 1}, - {&__pyx_n_s_KeyExportError, __pyx_k_KeyExportError, sizeof(__pyx_k_KeyExportError), 0, 0, 1, 1}, - {&__pyx_n_s_KeyGenerationError, __pyx_k_KeyGenerationError, sizeof(__pyx_k_KeyGenerationError), 0, 0, 1, 1}, - {&__pyx_n_s_KeyImportError, __pyx_k_KeyImportError, sizeof(__pyx_k_KeyImportError), 0, 0, 1, 1}, - {&__pyx_n_s_MACError, __pyx_k_MACError, sizeof(__pyx_k_MACError), 0, 0, 1, 1}, - {&__pyx_n_s_OptionError, __pyx_k_OptionError, sizeof(__pyx_k_OptionError), 0, 0, 1, 1}, - {&__pyx_n_s_OtherError, __pyx_k_OtherError, sizeof(__pyx_k_OtherError), 0, 0, 1, 1}, - {&__pyx_n_s_ProtocolError, __pyx_k_ProtocolError, sizeof(__pyx_k_ProtocolError), 0, 0, 1, 1}, - {&__pyx_n_s_ProtocolVersionNotSupport, __pyx_k_ProtocolVersionNotSupport, sizeof(__pyx_k_ProtocolVersionNotSupport), 0, 0, 1, 1}, - {&__pyx_kp_s_Raised_on_EOF_from_remote_channe, __pyx_k_Raised_on_EOF_from_remote_channe, sizeof(__pyx_k_Raised_on_EOF_from_remote_channe), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_GSS_API_errors, __pyx_k_Raised_on_GSS_API_errors, sizeof(__pyx_k_Raised_on_GSS_API_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_GSS_API_token_errors, __pyx_k_Raised_on_GSS_API_token_errors, sizeof(__pyx_k_Raised_on_GSS_API_token_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_MAC_errors, __pyx_k_Raised_on_MAC_errors, sizeof(__pyx_k_Raised_on_MAC_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_SFTP_errors, __pyx_k_Raised_on_SFTP_errors, sizeof(__pyx_k_Raised_on_SFTP_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_SFTP_handle_errors, __pyx_k_Raised_on_SFTP_handle_errors, sizeof(__pyx_k_Raised_on_SFTP_handle_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_SSH_channel_open_failu, __pyx_k_Raised_on_SSH_channel_open_failu, sizeof(__pyx_k_Raised_on_SSH_channel_open_failu), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_SSH_request_failures, __pyx_k_Raised_on_SSH_request_failures, sizeof(__pyx_k_Raised_on_SSH_request_failures), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_administratively_prohi, __pyx_k_Raised_on_administratively_prohi, sizeof(__pyx_k_Raised_on_administratively_prohi), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_authentication_denied, __pyx_k_Raised_on_authentication_denied, sizeof(__pyx_k_Raised_on_authentication_denied), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_compression_errors, __pyx_k_Raised_on_compression_errors, sizeof(__pyx_k_Raised_on_compression_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_connect_failure, __pyx_k_Raised_on_connect_failure, sizeof(__pyx_k_Raised_on_connect_failure), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_connection_lost, __pyx_k_Raised_on_connection_lost, sizeof(__pyx_k_Raised_on_connection_lost), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_disconnection_errors, __pyx_k_Raised_on_disconnection_errors, sizeof(__pyx_k_Raised_on_disconnection_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_errors_exporting_key, __pyx_k_Raised_on_errors_exporting_key, sizeof(__pyx_k_Raised_on_errors_exporting_key), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_errors_generating_key, __pyx_k_Raised_on_errors_generating_key, sizeof(__pyx_k_Raised_on_errors_generating_key), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_errors_getting_setting, __pyx_k_Raised_on_errors_getting_setting, sizeof(__pyx_k_Raised_on_errors_getting_setting), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_errors_importing_key, __pyx_k_Raised_on_errors_importing_key, sizeof(__pyx_k_Raised_on_errors_importing_key), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_errors_returned_by_lib, __pyx_k_Raised_on_errors_returned_by_lib, sizeof(__pyx_k_Raised_on_errors_returned_by_lib), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_fatal_errors_authentic, __pyx_k_Raised_on_fatal_errors_authentic, sizeof(__pyx_k_Raised_on_fatal_errors_authentic), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_host_authentication_fa, __pyx_k_Raised_on_host_authentication_fa, sizeof(__pyx_k_Raised_on_host_authentication_fa), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_host_key_not_verifiabl, __pyx_k_Raised_on_host_key_not_verifiabl, sizeof(__pyx_k_Raised_on_host_key_not_verifiabl), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_host_not_allowed_to_co, __pyx_k_Raised_on_host_not_allowed_to_co, sizeof(__pyx_k_Raised_on_host_not_allowed_to_co), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_invalid_uses_of_the_AP, __pyx_k_Raised_on_invalid_uses_of_the_AP, sizeof(__pyx_k_Raised_on_invalid_uses_of_the_AP), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_key_exchange_failures, __pyx_k_Raised_on_key_exchange_failures, sizeof(__pyx_k_Raised_on_key_exchange_failures), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_operations_on_closed_c, __pyx_k_Raised_on_operations_on_closed_c, sizeof(__pyx_k_Raised_on_operations_on_closed_c), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_other_non_specific_fat, __pyx_k_Raised_on_other_non_specific_fat, sizeof(__pyx_k_Raised_on_other_non_specific_fat), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_partial_authentication, __pyx_k_Raised_on_partial_authentication, sizeof(__pyx_k_Raised_on_partial_authentication), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_protocol_errors, __pyx_k_Raised_on_protocol_errors, sizeof(__pyx_k_Raised_on_protocol_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_protocol_version_not_s, __pyx_k_Raised_on_protocol_version_not_s, sizeof(__pyx_k_Raised_on_protocol_version_not_s), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_resource_shortage_erro, __pyx_k_Raised_on_resource_shortage_erro, sizeof(__pyx_k_Raised_on_resource_shortage_erro), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_service_not_available, __pyx_k_Raised_on_service_not_available, sizeof(__pyx_k_Raised_on_service_not_available), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_too_many_connection_er, __pyx_k_Raised_on_too_many_connection_er, sizeof(__pyx_k_Raised_on_too_many_connection_er), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_unimplemented_errors, __pyx_k_Raised_on_unimplemented_errors, sizeof(__pyx_k_Raised_on_unimplemented_errors), 0, 0, 1, 0}, - {&__pyx_kp_s_Raised_on_unknown_channel_type, __pyx_k_Raised_on_unknown_channel_type, sizeof(__pyx_k_Raised_on_unknown_channel_type), 0, 0, 1, 0}, - {&__pyx_n_s_RequestFailure, __pyx_k_RequestFailure, sizeof(__pyx_k_RequestFailure), 0, 0, 1, 1}, - {&__pyx_n_s_ResourceShortage, __pyx_k_ResourceShortage, sizeof(__pyx_k_ResourceShortage), 0, 0, 1, 1}, - {&__pyx_n_s_SFTPError, __pyx_k_SFTPError, sizeof(__pyx_k_SFTPError), 0, 0, 1, 1}, - {&__pyx_n_s_SFTPHandleError, __pyx_k_SFTPHandleError, sizeof(__pyx_k_SFTPHandleError), 0, 0, 1, 1}, - {&__pyx_n_s_SSHError, __pyx_k_SSHError, sizeof(__pyx_k_SSHError), 0, 0, 1, 1}, - {&__pyx_n_s_ServiceNotAvailable, __pyx_k_ServiceNotAvailable, sizeof(__pyx_k_ServiceNotAvailable), 0, 0, 1, 1}, - {&__pyx_n_s_TooManyConnections, __pyx_k_TooManyConnections, sizeof(__pyx_k_TooManyConnections), 0, 0, 1, 1}, - {&__pyx_n_s_UnImplemented, __pyx_k_UnImplemented, sizeof(__pyx_k_UnImplemented), 0, 0, 1, 1}, - {&__pyx_n_s_UnknownChannelType, __pyx_k_UnknownChannelType, sizeof(__pyx_k_UnknownChannelType), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, - {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, - {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, - {&__pyx_n_s_ssh_exceptions, __pyx_k_ssh_exceptions, sizeof(__pyx_k_ssh_exceptions), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1}, + {&__pyx_n_s_AdministrativelyProhibited, __pyx_k_AdministrativelyProhibited, sizeof(__pyx_k_AdministrativelyProhibited), 0, 0, 1, 1}, + {&__pyx_n_s_AuthenticationDenied, __pyx_k_AuthenticationDenied, sizeof(__pyx_k_AuthenticationDenied), 0, 0, 1, 1}, + {&__pyx_n_s_AuthenticationError, __pyx_k_AuthenticationError, sizeof(__pyx_k_AuthenticationError), 0, 0, 1, 1}, + {&__pyx_n_s_AuthenticationPartial, __pyx_k_AuthenticationPartial, sizeof(__pyx_k_AuthenticationPartial), 0, 0, 1, 1}, + {&__pyx_n_s_BaseSSHError, __pyx_k_BaseSSHError, sizeof(__pyx_k_BaseSSHError), 0, 0, 1, 1}, + {&__pyx_kp_s_Base_class_for_all_errors_produc, __pyx_k_Base_class_for_all_errors_produc, sizeof(__pyx_k_Base_class_for_all_errors_produc), 0, 0, 1, 0}, + {&__pyx_n_s_ChannelClosed, __pyx_k_ChannelClosed, sizeof(__pyx_k_ChannelClosed), 0, 0, 1, 1}, + {&__pyx_n_s_ChannelOpenFailure, __pyx_k_ChannelOpenFailure, sizeof(__pyx_k_ChannelOpenFailure), 0, 0, 1, 1}, + {&__pyx_n_s_CompressionError, __pyx_k_CompressionError, sizeof(__pyx_k_CompressionError), 0, 0, 1, 1}, + {&__pyx_n_s_ConnectFailed, __pyx_k_ConnectFailed, sizeof(__pyx_k_ConnectFailed), 0, 0, 1, 1}, + {&__pyx_n_s_ConnectionLost, __pyx_k_ConnectionLost, sizeof(__pyx_k_ConnectionLost), 0, 0, 1, 1}, + {&__pyx_n_s_Disconnected, __pyx_k_Disconnected, sizeof(__pyx_k_Disconnected), 0, 0, 1, 1}, + {&__pyx_n_s_EOF, __pyx_k_EOF, sizeof(__pyx_k_EOF), 0, 0, 1, 1}, + {&__pyx_n_s_GSSAPIError, __pyx_k_GSSAPIError, sizeof(__pyx_k_GSSAPIError), 0, 0, 1, 1}, + {&__pyx_n_s_GSSAPIErrorTok, __pyx_k_GSSAPIErrorTok, sizeof(__pyx_k_GSSAPIErrorTok), 0, 0, 1, 1}, + {&__pyx_n_s_HostAuthenticationFailed, __pyx_k_HostAuthenticationFailed, sizeof(__pyx_k_HostAuthenticationFailed), 0, 0, 1, 1}, + {&__pyx_n_s_HostKeyNotVerifiable, __pyx_k_HostKeyNotVerifiable, sizeof(__pyx_k_HostKeyNotVerifiable), 0, 0, 1, 1}, + {&__pyx_n_s_HostNotAllowedToConnect, __pyx_k_HostNotAllowedToConnect, sizeof(__pyx_k_HostNotAllowedToConnect), 0, 0, 1, 1}, + {&__pyx_n_s_InvalidAPIUse, __pyx_k_InvalidAPIUse, sizeof(__pyx_k_InvalidAPIUse), 0, 0, 1, 1}, + {&__pyx_n_s_KeyExchangeFailed, __pyx_k_KeyExchangeFailed, sizeof(__pyx_k_KeyExchangeFailed), 0, 0, 1, 1}, + {&__pyx_n_s_KeyExportError, __pyx_k_KeyExportError, sizeof(__pyx_k_KeyExportError), 0, 0, 1, 1}, + {&__pyx_n_s_KeyGenerationError, __pyx_k_KeyGenerationError, sizeof(__pyx_k_KeyGenerationError), 0, 0, 1, 1}, + {&__pyx_n_s_KeyImportError, __pyx_k_KeyImportError, sizeof(__pyx_k_KeyImportError), 0, 0, 1, 1}, + {&__pyx_n_s_MACError, __pyx_k_MACError, sizeof(__pyx_k_MACError), 0, 0, 1, 1}, + {&__pyx_n_s_OptionError, __pyx_k_OptionError, sizeof(__pyx_k_OptionError), 0, 0, 1, 1}, + {&__pyx_n_s_OtherError, __pyx_k_OtherError, sizeof(__pyx_k_OtherError), 0, 0, 1, 1}, + {&__pyx_n_s_ProtocolError, __pyx_k_ProtocolError, sizeof(__pyx_k_ProtocolError), 0, 0, 1, 1}, + {&__pyx_n_s_ProtocolVersionNotSupport, __pyx_k_ProtocolVersionNotSupport, sizeof(__pyx_k_ProtocolVersionNotSupport), 0, 0, 1, 1}, + {&__pyx_kp_s_Raised_on_EOF_from_remote_channe, __pyx_k_Raised_on_EOF_from_remote_channe, sizeof(__pyx_k_Raised_on_EOF_from_remote_channe), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_GSS_API_errors, __pyx_k_Raised_on_GSS_API_errors, sizeof(__pyx_k_Raised_on_GSS_API_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_GSS_API_token_errors, __pyx_k_Raised_on_GSS_API_token_errors, sizeof(__pyx_k_Raised_on_GSS_API_token_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_MAC_errors, __pyx_k_Raised_on_MAC_errors, sizeof(__pyx_k_Raised_on_MAC_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_SFTP_errors, __pyx_k_Raised_on_SFTP_errors, sizeof(__pyx_k_Raised_on_SFTP_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_SFTP_handle_errors, __pyx_k_Raised_on_SFTP_handle_errors, sizeof(__pyx_k_Raised_on_SFTP_handle_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_SSH_channel_open_failu, __pyx_k_Raised_on_SSH_channel_open_failu, sizeof(__pyx_k_Raised_on_SSH_channel_open_failu), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_SSH_request_failures, __pyx_k_Raised_on_SSH_request_failures, sizeof(__pyx_k_Raised_on_SSH_request_failures), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_administratively_prohi, __pyx_k_Raised_on_administratively_prohi, sizeof(__pyx_k_Raised_on_administratively_prohi), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_authentication_denied, __pyx_k_Raised_on_authentication_denied, sizeof(__pyx_k_Raised_on_authentication_denied), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_compression_errors, __pyx_k_Raised_on_compression_errors, sizeof(__pyx_k_Raised_on_compression_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_connect_failure, __pyx_k_Raised_on_connect_failure, sizeof(__pyx_k_Raised_on_connect_failure), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_connection_lost, __pyx_k_Raised_on_connection_lost, sizeof(__pyx_k_Raised_on_connection_lost), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_disconnection_errors, __pyx_k_Raised_on_disconnection_errors, sizeof(__pyx_k_Raised_on_disconnection_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_errors_exporting_key, __pyx_k_Raised_on_errors_exporting_key, sizeof(__pyx_k_Raised_on_errors_exporting_key), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_errors_generating_key, __pyx_k_Raised_on_errors_generating_key, sizeof(__pyx_k_Raised_on_errors_generating_key), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_errors_getting_setting, __pyx_k_Raised_on_errors_getting_setting, sizeof(__pyx_k_Raised_on_errors_getting_setting), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_errors_importing_key, __pyx_k_Raised_on_errors_importing_key, sizeof(__pyx_k_Raised_on_errors_importing_key), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_errors_returned_by_lib, __pyx_k_Raised_on_errors_returned_by_lib, sizeof(__pyx_k_Raised_on_errors_returned_by_lib), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_fatal_errors_authentic, __pyx_k_Raised_on_fatal_errors_authentic, sizeof(__pyx_k_Raised_on_fatal_errors_authentic), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_host_authentication_fa, __pyx_k_Raised_on_host_authentication_fa, sizeof(__pyx_k_Raised_on_host_authentication_fa), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_host_key_not_verifiabl, __pyx_k_Raised_on_host_key_not_verifiabl, sizeof(__pyx_k_Raised_on_host_key_not_verifiabl), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_host_not_allowed_to_co, __pyx_k_Raised_on_host_not_allowed_to_co, sizeof(__pyx_k_Raised_on_host_not_allowed_to_co), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_invalid_uses_of_the_AP, __pyx_k_Raised_on_invalid_uses_of_the_AP, sizeof(__pyx_k_Raised_on_invalid_uses_of_the_AP), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_key_exchange_failures, __pyx_k_Raised_on_key_exchange_failures, sizeof(__pyx_k_Raised_on_key_exchange_failures), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_operations_on_closed_c, __pyx_k_Raised_on_operations_on_closed_c, sizeof(__pyx_k_Raised_on_operations_on_closed_c), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_other_non_specific_fat, __pyx_k_Raised_on_other_non_specific_fat, sizeof(__pyx_k_Raised_on_other_non_specific_fat), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_partial_authentication, __pyx_k_Raised_on_partial_authentication, sizeof(__pyx_k_Raised_on_partial_authentication), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_protocol_errors, __pyx_k_Raised_on_protocol_errors, sizeof(__pyx_k_Raised_on_protocol_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_protocol_version_not_s, __pyx_k_Raised_on_protocol_version_not_s, sizeof(__pyx_k_Raised_on_protocol_version_not_s), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_resource_shortage_erro, __pyx_k_Raised_on_resource_shortage_erro, sizeof(__pyx_k_Raised_on_resource_shortage_erro), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_service_not_available, __pyx_k_Raised_on_service_not_available, sizeof(__pyx_k_Raised_on_service_not_available), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_too_many_connection_er, __pyx_k_Raised_on_too_many_connection_er, sizeof(__pyx_k_Raised_on_too_many_connection_er), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_unimplemented_errors, __pyx_k_Raised_on_unimplemented_errors, sizeof(__pyx_k_Raised_on_unimplemented_errors), 0, 0, 1, 0}, + {&__pyx_kp_s_Raised_on_unknown_channel_type, __pyx_k_Raised_on_unknown_channel_type, sizeof(__pyx_k_Raised_on_unknown_channel_type), 0, 0, 1, 0}, + {&__pyx_n_s_RequestFailure, __pyx_k_RequestFailure, sizeof(__pyx_k_RequestFailure), 0, 0, 1, 1}, + {&__pyx_n_s_ResourceShortage, __pyx_k_ResourceShortage, sizeof(__pyx_k_ResourceShortage), 0, 0, 1, 1}, + {&__pyx_n_s_SFTPError, __pyx_k_SFTPError, sizeof(__pyx_k_SFTPError), 0, 0, 1, 1}, + {&__pyx_n_s_SFTPHandleError, __pyx_k_SFTPHandleError, sizeof(__pyx_k_SFTPHandleError), 0, 0, 1, 1}, + {&__pyx_n_s_SSHError, __pyx_k_SSHError, sizeof(__pyx_k_SSHError), 0, 0, 1, 1}, + {&__pyx_n_s_ServiceNotAvailable, __pyx_k_ServiceNotAvailable, sizeof(__pyx_k_ServiceNotAvailable), 0, 0, 1, 1}, + {&__pyx_n_s_TooManyConnections, __pyx_k_TooManyConnections, sizeof(__pyx_k_TooManyConnections), 0, 0, 1, 1}, + {&__pyx_n_s_UnImplemented, __pyx_k_UnImplemented, sizeof(__pyx_k_UnImplemented), 0, 0, 1, 1}, + {&__pyx_n_s_UnknownChannelType, __pyx_k_UnknownChannelType, sizeof(__pyx_k_UnknownChannelType), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_init_subclass, __pyx_k_init_subclass, sizeof(__pyx_k_init_subclass), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_mro_entries, __pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1}, + {&__pyx_n_s_ssh_exceptions, __pyx_k_ssh_exceptions, sizeof(__pyx_k_ssh_exceptions), 0, 0, 1, 1}, + {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { return 0; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations @@ -1493,13 +2552,20 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyFinishContext(); return 0; } +/* #### Code section: init_constants ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -1566,6 +2632,55 @@ static int __Pyx_modinit_function_import_code(void) { } +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_exceptions(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_exceptions}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "exceptions", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 @@ -1616,12 +2731,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -1631,8 +2755,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -1642,8 +2767,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -1659,10 +2788,15 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_exceptions(PyObject *__pyx_pyinit_ #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; 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; @@ -1676,6 +2810,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_exceptions(PyObject *__pyx_pyinit_ #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("exceptions", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "exceptions" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -1686,7 +2847,7 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_exceptions(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif @@ -1694,48 +2855,31 @@ if (!__Pyx_RefNanny) { __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("exceptions", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -1747,7 +2891,7 @@ if (!__Pyx_RefNanny) { { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "ssh.exceptions")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.exceptions", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "ssh.exceptions", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif @@ -1775,22 +2919,28 @@ if (!__Pyx_RefNanny) { * """Raised on errors getting/setting options""" * */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - __Pyx_GIVEREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_OptionError, __pyx_n_s_OptionError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_getting_setting); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_INCREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); + __Pyx_GIVEREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])))) __PYX_ERR(0, 18, __pyx_L1_error); + __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_OptionError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_OptionError, __pyx_t_4) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_OptionError, __pyx_n_s_OptionError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_getting_setting); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 18, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_OptionError, __pyx_t_3, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_OptionError, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "ssh/exceptions.pyx":22 * @@ -1799,22 +2949,28 @@ if (!__Pyx_RefNanny) { * """Base class for all errors produced by libssh""" * */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - __Pyx_GIVEREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_BaseSSHError, __pyx_n_s_BaseSSHError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Base_class_for_all_errors_produc); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BaseSSHError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_INCREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); + __Pyx_GIVEREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])))) __PYX_ERR(0, 22, __pyx_L1_error); + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_BaseSSHError, __pyx_t_4) < 0) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_BaseSSHError, __pyx_n_s_BaseSSHError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Base_class_for_all_errors_produc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 22, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_BaseSSHError, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BaseSSHError, __pyx_t_3) < 0) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":26 * @@ -1823,24 +2979,30 @@ if (!__Pyx_RefNanny) { * """Raised on errors returned by libssh. * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_SSHError, __pyx_n_s_SSHError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_returned_by_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_SSHError, __pyx_n_s_SSHError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_returned_by_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_SSHError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSHError, __pyx_t_4) < 0) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 26, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SSHError, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSHError, __pyx_t_5) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":37 * @@ -1849,24 +3011,30 @@ if (!__Pyx_RefNanny) { * """Raised on other non-specific fatal errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_OtherError, __pyx_n_s_OtherError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_other_non_specific_fat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_OtherError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_OtherError, __pyx_t_4) < 0) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_OtherError, __pyx_n_s_OtherError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_other_non_specific_fat); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 37, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_OtherError, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_OtherError, __pyx_t_2) < 0) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":41 * @@ -1875,24 +3043,30 @@ if (!__Pyx_RefNanny) { * """Raised on authentication denied errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_AuthenticationDenied, __pyx_n_s_AuthenticationDenied, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_authentication_denied); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_AuthenticationDenied, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 41, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationDenied, __pyx_t_4) < 0) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_AuthenticationDenied, __pyx_n_s_AuthenticationDenied, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_authentication_denied); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 41, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_AuthenticationDenied, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationDenied, __pyx_t_3) < 0) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":45 * @@ -1901,24 +3075,30 @@ if (!__Pyx_RefNanny) { * """Raised on fatal errors authenticating""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_AuthenticationError, __pyx_n_s_AuthenticationError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_fatal_errors_authentic); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_AuthenticationError, __pyx_n_s_AuthenticationError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_fatal_errors_authentic); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AuthenticationError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationError, __pyx_t_4) < 0) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 45, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AuthenticationError, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationError, __pyx_t_5) < 0) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":49 * @@ -1927,24 +3107,30 @@ if (!__Pyx_RefNanny) { * """Raised on partial authentication""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_AuthenticationPartial, __pyx_n_s_AuthenticationPartial, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_partial_authentication); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_AuthenticationPartial, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationPartial, __pyx_t_4) < 0) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_AuthenticationPartial, __pyx_n_s_AuthenticationPartial, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_partial_authentication); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 49, __pyx_L1_error) + } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_AuthenticationPartial, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationPartial, __pyx_t_2) < 0) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":53 * @@ -1953,24 +3139,30 @@ if (!__Pyx_RefNanny) { * """Raised on errors exporting key""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KeyExportError, __pyx_n_s_KeyExportError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_exporting_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KeyExportError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExportError, __pyx_t_4) < 0) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_KeyExportError, __pyx_n_s_KeyExportError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_exporting_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 53, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_KeyExportError, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExportError, __pyx_t_3) < 0) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":57 * @@ -1979,24 +3171,30 @@ if (!__Pyx_RefNanny) { * """Raised on errors importing key""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KeyImportError, __pyx_n_s_KeyImportError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_importing_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_KeyImportError, __pyx_n_s_KeyImportError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_importing_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KeyImportError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyImportError, __pyx_t_4) < 0) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 57, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KeyImportError, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyImportError, __pyx_t_5) < 0) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":61 * @@ -2005,24 +3203,30 @@ if (!__Pyx_RefNanny) { * """Raised on errors generating key""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KeyGenerationError, __pyx_n_s_KeyGenerationError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_generating_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KeyGenerationError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyGenerationError, __pyx_t_4) < 0) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_KeyGenerationError, __pyx_n_s_KeyGenerationError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_errors_generating_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 61, __pyx_L1_error) + } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_KeyGenerationError, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyGenerationError, __pyx_t_2) < 0) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":65 * @@ -2031,24 +3235,30 @@ if (!__Pyx_RefNanny) { * """Raised on EOF from remote channel""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_EOF, __pyx_n_s_EOF, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_EOF_from_remote_channe); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_EOF, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_EOF, __pyx_t_4) < 0) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_EOF, __pyx_n_s_EOF, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_EOF_from_remote_channe); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 65, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_EOF, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EOF, __pyx_t_3) < 0) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":69 * @@ -2057,24 +3267,30 @@ if (!__Pyx_RefNanny) { * """Raised on invalid uses of the API""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_InvalidAPIUse, __pyx_n_s_InvalidAPIUse, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_invalid_uses_of_the_AP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_InvalidAPIUse, __pyx_n_s_InvalidAPIUse, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_invalid_uses_of_the_AP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_InvalidAPIUse, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidAPIUse, __pyx_t_4) < 0) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 69, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_InvalidAPIUse, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidAPIUse, __pyx_t_5) < 0) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":73 * @@ -2083,24 +3299,30 @@ if (!__Pyx_RefNanny) { * """Raised on disconnection errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_Disconnected, __pyx_n_s_Disconnected, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_disconnection_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_Disconnected, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Disconnected, __pyx_t_4) < 0) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_Disconnected, __pyx_n_s_Disconnected, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_disconnection_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 73, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_Disconnected, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Disconnected, __pyx_t_2) < 0) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":77 * @@ -2109,24 +3331,30 @@ if (!__Pyx_RefNanny) { * """Raised on unimplemented errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_UnImplemented, __pyx_n_s_UnImplemented, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_unimplemented_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_UnImplemented, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnImplemented, __pyx_t_4) < 0) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_UnImplemented, __pyx_n_s_UnImplemented, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_unimplemented_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 77, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_UnImplemented, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnImplemented, __pyx_t_3) < 0) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":81 * @@ -2135,24 +3363,30 @@ if (!__Pyx_RefNanny) { * """Raised on GSS API errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_GSSAPIError, __pyx_n_s_GSSAPIError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_GSS_API_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_GSSAPIError, __pyx_n_s_GSSAPIError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_GSS_API_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_GSSAPIError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_GSSAPIError, __pyx_t_4) < 0) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 81, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_GSSAPIError, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_GSSAPIError, __pyx_t_5) < 0) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":85 * @@ -2161,24 +3395,30 @@ if (!__Pyx_RefNanny) { * """Raised on GSS API token errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_GSSAPIErrorTok, __pyx_n_s_GSSAPIErrorTok, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_GSS_API_token_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_GSSAPIErrorTok, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_GSSAPIErrorTok, __pyx_t_4) < 0) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_GSSAPIErrorTok, __pyx_n_s_GSSAPIErrorTok, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_GSS_API_token_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 85, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_GSSAPIErrorTok, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_GSSAPIErrorTok, __pyx_t_2) < 0) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":89 * @@ -2187,24 +3427,30 @@ if (!__Pyx_RefNanny) { * """Raised on SSH request failures""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_RequestFailure, __pyx_n_s_RequestFailure, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SSH_request_failures); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_RequestFailure, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_RequestFailure, __pyx_t_4) < 0) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_RequestFailure, __pyx_n_s_RequestFailure, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SSH_request_failures); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 89, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_RequestFailure, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_RequestFailure, __pyx_t_3) < 0) __PYX_ERR(0, 89, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":93 * @@ -2213,24 +3459,30 @@ if (!__Pyx_RefNanny) { * """Raised on SSH channel open failures""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 93, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ChannelOpenFailure, __pyx_n_s_ChannelOpenFailure, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SSH_channel_open_failu); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_ChannelOpenFailure, __pyx_n_s_ChannelOpenFailure, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SSH_channel_open_failu); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelOpenFailure, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelOpenFailure, __pyx_t_4) < 0) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 93, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelOpenFailure, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelOpenFailure, __pyx_t_5) < 0) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":97 * @@ -2239,24 +3491,30 @@ if (!__Pyx_RefNanny) { * """Raised on host not allowed to connect errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_HostNotAllowedToConnect, __pyx_n_s_HostNotAllowedToConnect, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_host_not_allowed_to_co); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_HostNotAllowedToConnect, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostNotAllowedToConnect, __pyx_t_4) < 0) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_HostNotAllowedToConnect, __pyx_n_s_HostNotAllowedToConnect, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_host_not_allowed_to_co); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 97, __pyx_L1_error) + } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_HostNotAllowedToConnect, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostNotAllowedToConnect, __pyx_t_2) < 0) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":101 * @@ -2265,24 +3523,30 @@ if (!__Pyx_RefNanny) { * """Raised on protocol errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ProtocolError, __pyx_n_s_ProtocolError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_protocol_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ProtocolError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ProtocolError, __pyx_t_4) < 0) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_ProtocolError, __pyx_n_s_ProtocolError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_protocol_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 101, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ProtocolError, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ProtocolError, __pyx_t_3) < 0) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":105 * @@ -2291,24 +3555,30 @@ if (!__Pyx_RefNanny) { * """Raised on key exchange failures""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KeyExchangeFailed, __pyx_n_s_KeyExchangeFailed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_key_exchange_failures); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_KeyExchangeFailed, __pyx_n_s_KeyExchangeFailed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_key_exchange_failures); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KeyExchangeFailed, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExchangeFailed, __pyx_t_4) < 0) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 105, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KeyExchangeFailed, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExchangeFailed, __pyx_t_5) < 0) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":109 * @@ -2317,24 +3587,30 @@ if (!__Pyx_RefNanny) { * """Raised on host authentication failures""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 109, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_HostAuthenticationFailed, __pyx_n_s_HostAuthenticationFailed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_host_authentication_fa); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 109, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_HostAuthenticationFailed, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostAuthenticationFailed, __pyx_t_4) < 0) __PYX_ERR(0, 109, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_HostAuthenticationFailed, __pyx_n_s_HostAuthenticationFailed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_host_authentication_fa); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 109, __pyx_L1_error) + } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_HostAuthenticationFailed, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostAuthenticationFailed, __pyx_t_2) < 0) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":113 * @@ -2343,24 +3619,30 @@ if (!__Pyx_RefNanny) { * """Raised on MAC errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_MACError, __pyx_n_s_MACError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_MAC_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MACError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_MACError, __pyx_t_4) < 0) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_MACError, __pyx_n_s_MACError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_MAC_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 113, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_MACError, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MACError, __pyx_t_3) < 0) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":117 * @@ -2369,24 +3651,30 @@ if (!__Pyx_RefNanny) { * """Raised on compression errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_CompressionError, __pyx_n_s_CompressionError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_compression_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_CompressionError, __pyx_n_s_CompressionError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_compression_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_CompressionError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CompressionError, __pyx_t_4) < 0) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 117, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_CompressionError, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CompressionError, __pyx_t_5) < 0) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":121 * @@ -2395,24 +3683,30 @@ if (!__Pyx_RefNanny) { * """Raised on service not available errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ServiceNotAvailable, __pyx_n_s_ServiceNotAvailable, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_service_not_available); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ServiceNotAvailable, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ServiceNotAvailable, __pyx_t_4) < 0) __PYX_ERR(0, 121, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_ServiceNotAvailable, __pyx_n_s_ServiceNotAvailable, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_service_not_available); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 121, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_ServiceNotAvailable, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ServiceNotAvailable, __pyx_t_2) < 0) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":125 * @@ -2421,24 +3715,30 @@ if (!__Pyx_RefNanny) { * """Raised on protocol version not supported""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ProtocolVersionNotSupport, __pyx_n_s_ProtocolVersionNotSupport, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_protocol_version_not_s); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ProtocolVersionNotSupport, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 125, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ProtocolVersionNotSupport, __pyx_t_4) < 0) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_ProtocolVersionNotSupport, __pyx_n_s_ProtocolVersionNotSupport, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_protocol_version_not_s); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 125, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ProtocolVersionNotSupport, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ProtocolVersionNotSupport, __pyx_t_3) < 0) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":129 * @@ -2447,24 +3747,30 @@ if (!__Pyx_RefNanny) { * """Raised on host key not verifiable errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 129, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_HostKeyNotVerifiable, __pyx_n_s_HostKeyNotVerifiable, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_host_key_not_verifiabl); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_HostKeyNotVerifiable, __pyx_n_s_HostKeyNotVerifiable, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_host_key_not_verifiabl); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_HostKeyNotVerifiable, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostKeyNotVerifiable, __pyx_t_4) < 0) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 129, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_HostKeyNotVerifiable, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostKeyNotVerifiable, __pyx_t_5) < 0) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":133 * @@ -2473,24 +3779,30 @@ if (!__Pyx_RefNanny) { * """Raised on connection lost""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ConnectionLost, __pyx_n_s_ConnectionLost, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_connection_lost); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ConnectionLost, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 133, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ConnectionLost, __pyx_t_4) < 0) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_ConnectionLost, __pyx_n_s_ConnectionLost, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_connection_lost); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 133, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_ConnectionLost, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ConnectionLost, __pyx_t_2) < 0) __PYX_ERR(0, 133, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":137 * @@ -2499,24 +3811,30 @@ if (!__Pyx_RefNanny) { * """Raised on too many connection errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_TooManyConnections, __pyx_n_s_TooManyConnections, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_too_many_connection_er); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_TooManyConnections, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 137, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TooManyConnections, __pyx_t_4) < 0) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_TooManyConnections, __pyx_n_s_TooManyConnections, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_too_many_connection_er); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 137, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_TooManyConnections, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TooManyConnections, __pyx_t_3) < 0) __PYX_ERR(0, 137, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":141 * @@ -2525,24 +3843,30 @@ if (!__Pyx_RefNanny) { * """Raised on administratively prohibited errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_AdministrativelyProhibited, __pyx_n_s_AdministrativelyProhibited, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_administratively_prohi); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_AdministrativelyProhibited, __pyx_n_s_AdministrativelyProhibited, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_administratively_prohi); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AdministrativelyProhibited, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_AdministrativelyProhibited, __pyx_t_4) < 0) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 141, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AdministrativelyProhibited, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AdministrativelyProhibited, __pyx_t_5) < 0) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":145 * @@ -2551,24 +3875,30 @@ if (!__Pyx_RefNanny) { * """Raised on connect failure""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ConnectFailed, __pyx_n_s_ConnectFailed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_connect_failure); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ConnectFailed, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ConnectFailed, __pyx_t_4) < 0) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_ConnectFailed, __pyx_n_s_ConnectFailed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_connect_failure); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 145, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_ConnectFailed, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ConnectFailed, __pyx_t_2) < 0) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":149 * @@ -2577,24 +3907,30 @@ if (!__Pyx_RefNanny) { * """Raised on unknown channel type""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_UnknownChannelType, __pyx_n_s_UnknownChannelType, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_unknown_channel_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_UnknownChannelType, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnknownChannelType, __pyx_t_4) < 0) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_UnknownChannelType, __pyx_n_s_UnknownChannelType, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_unknown_channel_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 149, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_UnknownChannelType, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnknownChannelType, __pyx_t_3) < 0) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":153 * @@ -2603,24 +3939,30 @@ if (!__Pyx_RefNanny) { * """Raised on resource shortage errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ResourceShortage, __pyx_n_s_ResourceShortage, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_resource_shortage_erro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_ResourceShortage, __pyx_n_s_ResourceShortage, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_resource_shortage_erro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ResourceShortage, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ResourceShortage, __pyx_t_4) < 0) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 153, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ResourceShortage, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ResourceShortage, __pyx_t_5) < 0) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":157 * @@ -2629,24 +3971,30 @@ if (!__Pyx_RefNanny) { * """Raised on SFTP errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SFTPError, __pyx_n_s_SFTPError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SFTP_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SFTPError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPError, __pyx_t_4) < 0) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_SFTPError, __pyx_n_s_SFTPError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SFTP_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_4 != __pyx_t_2) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 157, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_SFTPError, __pyx_t_4, __pyx_t_5, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPError, __pyx_t_2) < 0) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":161 * @@ -2655,24 +4003,30 @@ if (!__Pyx_RefNanny) { * """Raised on SFTP handle errors""" * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SFTPError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_SFTPHandleError, __pyx_n_s_SFTPHandleError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SFTP_handle_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_SFTPError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_SFTPHandleError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPHandleError, __pyx_t_4) < 0) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_4, __pyx_n_s_SFTPHandleError, __pyx_n_s_SFTPHandleError, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_SFTP_handle_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 161, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_SFTPHandleError, __pyx_t_4, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPHandleError, __pyx_t_3) < 0) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":165 * @@ -2680,48 +4034,64 @@ if (!__Pyx_RefNanny) { * class ChannelClosed(BaseSSHError): # <<<<<<<<<<<<<< * """Raised on operations on closed channels""" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_BaseSSHError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ChannelClosed, __pyx_n_s_ChannelClosed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_operations_on_closed_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error) + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_4, __pyx_n_s_ChannelClosed, __pyx_n_s_ChannelClosed, (PyObject *) NULL, __pyx_n_s_ssh_exceptions, __pyx_kp_s_Raised_on_operations_on_closed_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelClosed, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelClosed, __pyx_t_4) < 0) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_4 != __pyx_t_5) { + if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 165, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelClosed, __pyx_t_4, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelClosed, __pyx_t_5) < 0) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "ssh/exceptions.pyx":1 * # This file is part of ssh-python. # <<<<<<<<<<<<<< * # Copyright (C) 2018 Panos Kittenis * # */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_4) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init ssh.exceptions", __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 ssh.exceptions"); } @@ -2735,6 +4105,22 @@ if (!__Pyx_RefNanny) { return; #endif } +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ @@ -2754,12 +4140,493 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); + } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* Py3UpdateBases */ +static PyObject* +__Pyx_PEP560_update_bases(PyObject *bases) +{ + Py_ssize_t i, j, size_bases; + PyObject *base, *meth, *new_base, *result, *new_bases = NULL; + size_bases = PyTuple_GET_SIZE(bases); + for (i = 0; i < size_bases; i++) { + base = PyTuple_GET_ITEM(bases, i); + if (PyType_Check(base)) { + if (new_bases) { + if (PyList_Append(new_bases, base) < 0) { + goto error; + } + } + continue; + } + meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_n_s_mro_entries); + if (!meth && PyErr_Occurred()) { + goto error; + } + if (!meth) { + if (new_bases) { + if (PyList_Append(new_bases, base) < 0) { + goto error; + } + } + continue; + } + new_base = __Pyx_PyObject_CallOneArg(meth, bases); + Py_DECREF(meth); + if (!new_base) { + goto error; + } + if (!PyTuple_Check(new_base)) { + PyErr_SetString(PyExc_TypeError, + "__mro_entries__ must return a tuple"); + Py_DECREF(new_base); + goto error; + } + if (!new_bases) { + if (!(new_bases = PyList_New(i))) { + goto error; + } + for (j = 0; j < i; j++) { + base = PyTuple_GET_ITEM(bases, j); + PyList_SET_ITEM(new_bases, j, base); + Py_INCREF(base); + } + } + j = PyList_GET_SIZE(new_bases); + if (PyList_SetSlice(new_bases, j, j, new_base) < 0) { + goto error; + } + Py_DECREF(new_base); + } + if (!new_bases) { + Py_INCREF(bases); + return bases; + } + result = PyList_AsTuple(new_bases); + Py_DECREF(new_bases); + return result; +error: + Py_XDECREF(new_bases); + return NULL; +} + /* CalculateMetaclass */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { - Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + Py_ssize_t i, nbases; +#if CYTHON_ASSUME_SAFE_MACROS + nbases = PyTuple_GET_SIZE(bases); +#else + nbases = PyTuple_Size(bases); + if (nbases < 0) return NULL; +#endif for (i=0; i < nbases; i++) { PyTypeObject *tmptype; +#if CYTHON_ASSUME_SAFE_MACROS PyObject *tmp = PyTuple_GET_ITEM(bases, i); +#else + PyObject *tmp = PyTuple_GetItem(bases, i); + if (!tmp) return NULL; +#endif tmptype = Py_TYPE(tmp); #if PY_MAJOR_VERSION < 3 if (tmptype == &PyClass_Type) @@ -2793,17 +4660,47 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas return (PyObject*) metaclass; } -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif - return PyObject_GetAttr(obj, attr_name); + } + return result; +} + +/* PyObjectCall2Args */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* 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); +#if PY_MAJOR_VERSION < 3 + if (unlikely(PyInstance_Check(obj))) + return with_error ? __Pyx_PyObject_GetAttrStr(obj, attr_name) : __Pyx_PyObject_GetAttrStrNoError(obj, attr_name); +#endif + 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 @@ -2812,20 +4709,14 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { PyObject *ns; if (metaclass) { - PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_n_s_prepare); if (prep) { - PyObject *pargs = PyTuple_Pack(2, name, bases); - if (unlikely(!pargs)) { - Py_DECREF(prep); - return NULL; - } - ns = PyObject_Call(prep, pargs, mkw); + PyObject *pargs[3] = {NULL, name, bases}; + ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); Py_DECREF(prep); - Py_DECREF(pargs); } else { - if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + if (unlikely(PyErr_Occurred())) return NULL; - PyErr_Clear(); ns = PyDict_New(); } } else { @@ -2834,18 +4725,153 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, if (unlikely(!ns)) return NULL; if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; +#if PY_VERSION_HEX >= 0x03030000 if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; +#else + CYTHON_MAYBE_UNUSED_VAR(qualname); +#endif if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; return ns; bad: Py_DECREF(ns); return NULL; } +#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS +static int __Pyx_SetNamesPEP487(PyObject *type_obj) { + PyTypeObject *type = (PyTypeObject*) type_obj; + PyObject *names_to_set, *key, *value, *set_name, *tmp; + Py_ssize_t i = 0; +#if CYTHON_USE_TYPE_SLOTS + names_to_set = PyDict_Copy(type->tp_dict); +#else + { + PyObject *d = PyObject_GetAttr(type_obj, __pyx_n_s_dict); + names_to_set = NULL; + if (likely(d)) { + PyObject *names_to_set = PyDict_New(); + int ret = likely(names_to_set) ? PyDict_Update(names_to_set, d) : -1; + Py_DECREF(d); + if (unlikely(ret < 0)) + Py_CLEAR(names_to_set); + } + } +#endif + if (unlikely(names_to_set == NULL)) + goto bad; + while (PyDict_Next(names_to_set, &i, &key, &value)) { + set_name = __Pyx_PyObject_LookupSpecialNoError(value, __pyx_n_s_set_name); + if (unlikely(set_name != NULL)) { + tmp = __Pyx_PyObject_Call2Args(set_name, type_obj, key); + Py_DECREF(set_name); + if (unlikely(tmp == NULL)) { + __Pyx_TypeName value_type_name = + __Pyx_PyType_GetName(Py_TYPE(value)); + __Pyx_TypeName type_name = __Pyx_PyType_GetName(type); + PyErr_Format(PyExc_RuntimeError, +#if PY_MAJOR_VERSION >= 3 + "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %R " "in '" __Pyx_FMT_TYPENAME "'", + value_type_name, key, type_name); +#else + "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %.100s in '" __Pyx_FMT_TYPENAME "'", + value_type_name, + PyString_Check(key) ? PyString_AS_STRING(key) : "?", + type_name); +#endif + goto bad; + } else { + Py_DECREF(tmp); + } + } + else if (unlikely(PyErr_Occurred())) { + goto bad; + } + } + Py_DECREF(names_to_set); + return 0; +bad: + Py_XDECREF(names_to_set); + return -1; +} +static PyObject *__Pyx_InitSubclassPEP487(PyObject *type_obj, PyObject *mkw) { +#if CYTHON_USE_TYPE_SLOTS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyTypeObject *type = (PyTypeObject*) type_obj; + PyObject *mro = type->tp_mro; + Py_ssize_t i, nbases; + if (unlikely(!mro)) goto done; + (void) &__Pyx_GetBuiltinName; + Py_INCREF(mro); + nbases = PyTuple_GET_SIZE(mro); + assert(PyTuple_GET_ITEM(mro, 0) == type_obj); + for (i = 1; i < nbases-1; i++) { + PyObject *base, *dict, *meth; + base = PyTuple_GET_ITEM(mro, i); + dict = ((PyTypeObject *)base)->tp_dict; + meth = __Pyx_PyDict_GetItemStrWithError(dict, __pyx_n_s_init_subclass); + if (unlikely(meth)) { + descrgetfunc f = Py_TYPE(meth)->tp_descr_get; + PyObject *res; + Py_INCREF(meth); + if (likely(f)) { + res = f(meth, NULL, type_obj); + Py_DECREF(meth); + if (unlikely(!res)) goto bad; + meth = res; + } + res = __Pyx_PyObject_FastCallDict(meth, NULL, 0, mkw); + Py_DECREF(meth); + if (unlikely(!res)) goto bad; + Py_DECREF(res); + goto done; + } else if (unlikely(PyErr_Occurred())) { + goto bad; + } + } +done: + Py_XDECREF(mro); + return type_obj; +bad: + Py_XDECREF(mro); + Py_DECREF(type_obj); + return NULL; +#else + PyObject *super_type, *super, *func, *res; +#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) + super_type = __Pyx_GetBuiltinName(__pyx_n_s_super); +#else + super_type = (PyObject*) &PySuper_Type; + (void) &__Pyx_GetBuiltinName; +#endif + super = likely(super_type) ? __Pyx_PyObject_Call2Args(super_type, type_obj, type_obj) : NULL; +#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) + Py_XDECREF(super_type); +#endif + if (unlikely(!super)) { + Py_CLEAR(type_obj); + goto done; + } + func = __Pyx_PyObject_GetAttrStrNoError(super, __pyx_n_s_init_subclass); + Py_DECREF(super); + if (likely(!func)) { + if (unlikely(PyErr_Occurred())) + Py_CLEAR(type_obj); + goto done; + } + res = __Pyx_PyObject_FastCallDict(func, NULL, 0, mkw); + Py_DECREF(func); + if (unlikely(!res)) + Py_CLEAR(type_obj); + Py_XDECREF(res); +done: + return type_obj; +#endif +} +#endif static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass) { - PyObject *result, *margs; + PyObject *result; PyObject *owned_metaclass = NULL; + PyObject *margs[4] = {NULL, name, bases, dict}; if (allow_py2_metaclass) { owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); if (owned_metaclass) { @@ -2863,28 +4889,25 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj return NULL; owned_metaclass = metaclass; } - margs = PyTuple_Pack(3, name, bases, dict); - if (unlikely(!margs)) { - result = NULL; - } else { - result = PyObject_Call(metaclass, margs, mkw); - Py_DECREF(margs); - } - Py_XDECREF(owned_metaclass); - return result; -} - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); + result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, +#if PY_VERSION_HEX < 0x030600A4 + (metaclass == (PyObject*)&PyType_Type) ? NULL : mkw #else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + mkw #endif + ); + Py_XDECREF(owned_metaclass); +#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS + if (likely(result) && likely(PyType_Check(result))) { + if (unlikely(__Pyx_SetNamesPEP487(result) < 0)) { + Py_CLEAR(result); + } else { + result = __Pyx_InitSubclassPEP487(result, mkw); + } } +#else + (void) &__Pyx_GetBuiltinName; +#endif return result; } @@ -2923,7 +4946,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { @@ -2931,6 +4954,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) } else if (unlikely(PyErr_Occurred())) { return NULL; } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) @@ -2949,38 +4980,15 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) return __Pyx_GetBuiltinName(name); } -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -2994,7 +5002,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -3016,6 +5024,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -3094,17 +5103,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -3139,6 +5232,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -3154,7 +5248,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -3201,6 +5295,23 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s_); + } + return name; +} +#endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { @@ -3235,8 +5346,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -3275,7 +5412,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -3289,40 +5426,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -3335,109 +5477,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -3471,7 +5685,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -3485,40 +5699,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -3531,109 +5750,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -3658,7 +5949,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -3679,6 +5970,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -3703,11 +6010,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -3755,47 +6062,78 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -3803,30 +6141,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -3881,7 +6223,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -3910,22 +6252,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -3991,13 +6337,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -4065,4 +6409,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/key.c b/ssh/key.c index 23fa0836..71f7a206 100644 --- a/ssh/key.c +++ b/ssh/key.c @@ -1,22 +1,72 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.key", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/key.pyx" + ] + }, + "module_name": "ssh.key" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +85,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +93,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +130,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +150,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +278,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +307,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +318,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +341,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +368,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +392,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +476,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +500,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +517,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +579,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +614,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +766,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +783,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +873,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +919,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +953,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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 + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1047,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1062,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1104,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1121,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1168,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1188,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1228,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -794,9 +1305,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -814,9 +1326,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -824,13 +1336,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -854,13 +1360,59 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); @@ -876,7 +1428,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -906,6 +1458,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -941,24 +1494,27 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "ssh/key.pyx", - "stringsource", + "", "ssh/keytypes.pxd", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -966,11 +1522,9 @@ static const char *__pyx_f[] = { #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_3ssh_8keytypes_KeyType; @@ -1185,6 +1739,7 @@ struct __pyx_vtabstruct_3ssh_3key_SSHKey { struct __pyx_obj_3ssh_3key_SSHKey *(*from_ptr)(ssh_key); }; static struct __pyx_vtabstruct_3ssh_3key_SSHKey *__pyx_vtabptr_3ssh_3key_SSHKey; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1193,11 +1748,11 @@ static struct __pyx_vtabstruct_3ssh_3key_SSHKey *__pyx_vtabptr_3ssh_3key_SSHKey; #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1207,28 +1762,40 @@ static struct __pyx_vtabstruct_3ssh_3key_SSHKey *__pyx_vtabptr_3ssh_3key_SSHKey; #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1239,6 +1806,10 @@ static struct __pyx_vtabstruct_3ssh_3key_SSHKey *__pyx_vtabptr_3ssh_3key_SSHKey; #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);\ @@ -1250,6 +1821,57 @@ static struct __pyx_vtabstruct_3ssh_3key_SSHKey *__pyx_vtabptr_3ssh_3key_SSHKey; #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); @@ -1257,19 +1879,86 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); @@ -1277,8 +1966,9 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name); /* PyDictVersioning.proto */ @@ -1309,18 +1999,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) @@ -1328,105 +2018,88 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif -#if CYTHON_FAST_PYCALL - static size_t __pyx_pyframe_localsplus_offset = 0; +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif // CYTHON_FAST_PYCALL +#endif +#endif #endif -/* PyObjectCallMethO.proto */ +/* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +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 -/* PyObjectCallNoArg.proto */ +/* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); -#else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); + +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); #endif +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); @@ -1442,31 +2115,38 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif /* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 +#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 }; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); #endif /* Import.proto */ @@ -1475,6 +2155,146 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) @@ -1483,6 +2303,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1496,19 +2317,33 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1518,80 +2353,87 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionImport.proto */ -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ static struct __pyx_obj_3ssh_3key_SSHKey *__pyx_f_3ssh_3key_6SSHKey_from_ptr(ssh_key __pyx_v_key); /* proto*/ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "libc.time" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'ssh.keytypes' */ -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_KeyType = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSKey = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSAKey = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSA1Key = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSAKey = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSCert01Key = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSACert01Key = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ED25519_CERT01 = 0; +/* Module declarations from "ssh.keytypes" */ static struct __pyx_obj_3ssh_8keytypes_KeyType *(*__pyx_f_3ssh_8keytypes_from_keytype)(enum ssh_keytypes_e); /*proto*/ -/* Module declarations from 'ssh.utils' */ +/* Module declarations from "ssh.utils" */ static PyObject *(*__pyx_f_3ssh_5utils_to_bytes)(PyObject *); /*proto*/ static PyObject *(*__pyx_f_3ssh_5utils_to_str)(char const *); /*proto*/ -/* Module declarations from 'ssh.key' */ -static PyTypeObject *__pyx_ptype_3ssh_3key_SSHKey = 0; +/* Module declarations from "ssh.key" */ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.key" extern int __pyx_module_is_main_ssh__key; int __pyx_module_is_main_ssh__key = 0; -/* Implementation of 'ssh.key' */ +/* Implementation of "ssh.key" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_TypeError; -static const char __pyx_k__3[] = ""; +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = ""; +static const char __pyx_k__2[] = "."; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_rc[] = "rc"; -static const char __pyx_k_key[] = "key"; +static const char __pyx_k__37[] = "?"; +static const char __pyx_k_key[] = "_key"; static const char __pyx_k_bits[] = "bits"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_type[] = "_type"; +static const char __pyx_k_b_key[] = "b_key"; static const char __pyx_k_c_key[] = "c_key"; -static const char __pyx_k_key_2[] = "_key"; +static const char __pyx_k_key_2[] = "key"; static const char __pyx_k_SSHKey[] = "SSHKey"; +static const char __pyx_k_b_name[] = "b_name"; +static const char __pyx_k_c_name[] = "c_name"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_b64_key[] = "b64_key"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_key_len[] = "key_len"; +static const char __pyx_k_pub_key[] = "pub_key"; static const char __pyx_k_ssh_key[] = "ssh.key"; static const char __pyx_k_b64_cert[] = "b64_cert"; static const char __pyx_k_cert_key[] = "cert_key"; @@ -1602,10 +2444,15 @@ static const char __pyx_k_key_type[] = "key_type"; static const char __pyx_k_priv_key[] = "priv_key"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_is_public[] = "is_public"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_pub_key_2[] = "_pub_key"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_b_filepath[] = "b_filepath"; static const char __pyx_k_c_filepath[] = "c_filepath"; static const char __pyx_k_cert_key_2[] = "_cert_key"; +static const char __pyx_k_ecdsa_name[] = "ecdsa_name"; static const char __pyx_k_exceptions[] = "exceptions"; static const char __pyx_k_is_private[] = "is_private"; static const char __pyx_k_passphrase[] = "passphrase"; @@ -1615,70 +2462,36 @@ static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_ssh_key_pyx[] = "ssh/key.pyx"; static const char __pyx_k_b_passphrase[] = "b_passphrase"; static const char __pyx_k_c_passphrase[] = "c_passphrase"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_stringsource[] = ""; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_KeyExportError[] = "KeyExportError"; static const char __pyx_k_KeyImportError[] = "KeyImportError"; +static const char __pyx_k_SSHKey_key_type[] = "SSHKey.key_type"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_SSHKey_is_public[] = "SSHKey.is_public"; static const char __pyx_k_import_cert_file[] = "import_cert_file"; +static const char __pyx_k_SSHKey_ecdsa_name[] = "SSHKey.ecdsa_name"; +static const char __pyx_k_SSHKey_is_private[] = "SSHKey.is_private"; static const char __pyx_k_KeyGenerationError[] = "KeyGenerationError"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_import_cert_base64[] = "import_cert_base64"; static const char __pyx_k_import_pubkey_file[] = "import_pubkey_file"; +static const char __pyx_k_export_privkey_file[] = "export_privkey_file"; static const char __pyx_k_import_privkey_file[] = "import_privkey_file"; static const char __pyx_k_copy_cert_to_privkey[] = "copy_cert_to_privkey"; +static const char __pyx_k_export_pubkey_base64[] = "export_pubkey_base64"; static const char __pyx_k_import_pubkey_base64[] = "import_pubkey_base64"; static const char __pyx_k_import_privkey_base64[] = "import_privkey_base64"; +static const char __pyx_k_SSHKey___reduce_cython[] = "SSHKey.__reduce_cython__"; +static const char __pyx_k_SSHKey___setstate_cython[] = "SSHKey.__setstate_cython__"; +static const char __pyx_k_export_privkey_to_pubkey[] = "export_privkey_to_pubkey"; +static const char __pyx_k_SSHKey_export_privkey_file[] = "SSHKey.export_privkey_file"; +static const char __pyx_k_SSHKey_export_pubkey_base64[] = "SSHKey.export_pubkey_base64"; +static const char __pyx_k_SSHKey_export_privkey_to_pubkey[] = "SSHKey.export_privkey_to_pubkey"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static PyObject *__pyx_n_s_KeyExportError; -static PyObject *__pyx_n_s_KeyGenerationError; -static PyObject *__pyx_n_s_KeyImportError; -static PyObject *__pyx_n_s_MemoryError; -static PyObject *__pyx_n_s_SSHKey; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_kp_b__3; -static PyObject *__pyx_n_s_b64_cert; -static PyObject *__pyx_n_s_b64_key; -static PyObject *__pyx_n_s_b_filepath; -static PyObject *__pyx_n_s_b_passphrase; -static PyObject *__pyx_n_s_bits; -static PyObject *__pyx_n_s_c_filepath; -static PyObject *__pyx_n_s_c_key; -static PyObject *__pyx_n_s_c_passphrase; -static PyObject *__pyx_n_s_cert_key; -static PyObject *__pyx_n_s_cert_key_2; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_copy_cert_to_privkey; -static PyObject *__pyx_n_s_exceptions; -static PyObject *__pyx_n_s_filepath; -static PyObject *__pyx_n_s_generate; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_import_cert_base64; -static PyObject *__pyx_n_s_import_cert_file; -static PyObject *__pyx_n_s_import_privkey_base64; -static PyObject *__pyx_n_s_import_privkey_file; -static PyObject *__pyx_n_s_import_pubkey_base64; -static PyObject *__pyx_n_s_import_pubkey_file; -static PyObject *__pyx_n_s_is_private; -static PyObject *__pyx_n_s_key; -static PyObject *__pyx_n_s_key_2; -static PyObject *__pyx_n_s_key_type; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_n_s_passphrase; -static PyObject *__pyx_n_s_priv_key; -static PyObject *__pyx_n_s_priv_key_2; -static PyObject *__pyx_n_s_pyx_vtable; -static PyObject *__pyx_n_s_rc; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_ssh_key; -static PyObject *__pyx_kp_s_ssh_key_pyx; -static PyObject *__pyx_n_s_test; +/* #### Code section: decls ### */ static int __pyx_pf_3ssh_3key_6SSHKey___cinit__(struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_self); /* proto */ static void __pyx_pf_3ssh_3key_6SSHKey_2__dealloc__(struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_4is_private(struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_self); /* proto */ @@ -1700,25 +2513,684 @@ static PyObject *__pyx_pf_3ssh_3key_10import_cert_base64(CYTHON_UNUSED PyObject static PyObject *__pyx_pf_3ssh_3key_12import_cert_file(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filepath); /* proto */ static PyObject *__pyx_pf_3ssh_3key_14copy_cert_to_privkey(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_cert_key, struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_priv_key); /* proto */ static PyObject *__pyx_tp_new_3ssh_3key_SSHKey(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__4; -static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__8; -static PyObject *__pyx_tuple__10; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__14; -static PyObject *__pyx_tuple__16; -static PyObject *__pyx_tuple__18; -static PyObject *__pyx_codeobj__5; -static PyObject *__pyx_codeobj__7; -static PyObject *__pyx_codeobj__9; -static PyObject *__pyx_codeobj__11; -static PyObject *__pyx_codeobj__13; -static PyObject *__pyx_codeobj__15; -static PyObject *__pyx_codeobj__17; -static PyObject *__pyx_codeobj__19; -/* Late includes */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_3ssh_8keytypes_KeyType; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSKey; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSAKey; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSA1Key; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSAKey; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSCert01Key; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSACert01Key; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ED25519_CERT01; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_3ssh_3key_SSHKey; + #endif + PyTypeObject *__pyx_ptype_3ssh_3key_SSHKey; + PyObject *__pyx_kp_b_; + PyObject *__pyx_n_s_KeyExportError; + PyObject *__pyx_n_s_KeyGenerationError; + PyObject *__pyx_n_s_KeyImportError; + PyObject *__pyx_n_s_MemoryError; + PyObject *__pyx_n_s_SSHKey; + PyObject *__pyx_n_s_SSHKey___reduce_cython; + PyObject *__pyx_n_s_SSHKey___setstate_cython; + PyObject *__pyx_n_s_SSHKey_ecdsa_name; + PyObject *__pyx_n_s_SSHKey_export_privkey_file; + PyObject *__pyx_n_s_SSHKey_export_privkey_to_pubkey; + PyObject *__pyx_n_s_SSHKey_export_pubkey_base64; + PyObject *__pyx_n_s_SSHKey_is_private; + PyObject *__pyx_n_s_SSHKey_is_public; + PyObject *__pyx_n_s_SSHKey_key_type; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_kp_u__2; + PyObject *__pyx_n_s__37; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_b64_cert; + PyObject *__pyx_n_s_b64_key; + PyObject *__pyx_n_s_b_filepath; + PyObject *__pyx_n_s_b_key; + PyObject *__pyx_n_s_b_name; + PyObject *__pyx_n_s_b_passphrase; + PyObject *__pyx_n_s_bits; + PyObject *__pyx_n_s_c_filepath; + PyObject *__pyx_n_s_c_key; + PyObject *__pyx_n_s_c_name; + PyObject *__pyx_n_s_c_passphrase; + PyObject *__pyx_n_s_cert_key; + PyObject *__pyx_n_s_cert_key_2; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_copy_cert_to_privkey; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_n_s_ecdsa_name; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_exceptions; + PyObject *__pyx_n_s_export_privkey_file; + PyObject *__pyx_n_s_export_privkey_to_pubkey; + PyObject *__pyx_n_s_export_pubkey_base64; + PyObject *__pyx_n_s_filepath; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_generate; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_import_cert_base64; + PyObject *__pyx_n_s_import_cert_file; + PyObject *__pyx_n_s_import_privkey_base64; + PyObject *__pyx_n_s_import_privkey_file; + PyObject *__pyx_n_s_import_pubkey_base64; + PyObject *__pyx_n_s_import_pubkey_file; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_n_s_is_private; + PyObject *__pyx_n_s_is_public; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_key; + PyObject *__pyx_n_s_key_2; + PyObject *__pyx_n_s_key_len; + PyObject *__pyx_n_s_key_type; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_passphrase; + PyObject *__pyx_n_s_priv_key; + PyObject *__pyx_n_s_priv_key_2; + PyObject *__pyx_n_s_pub_key; + PyObject *__pyx_n_s_pub_key_2; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_rc; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_ssh_key; + PyObject *__pyx_kp_s_ssh_key_pyx; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_type; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__6; + PyObject *__pyx_tuple__8; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__12; + PyObject *__pyx_tuple__13; + PyObject *__pyx_tuple__15; + PyObject *__pyx_tuple__17; + PyObject *__pyx_tuple__19; + PyObject *__pyx_tuple__21; + PyObject *__pyx_tuple__23; + PyObject *__pyx_tuple__25; + PyObject *__pyx_tuple__26; + PyObject *__pyx_tuple__28; + PyObject *__pyx_tuple__30; + PyObject *__pyx_tuple__32; + PyObject *__pyx_tuple__35; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__5; + PyObject *__pyx_codeobj__7; + PyObject *__pyx_codeobj__9; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__14; + PyObject *__pyx_codeobj__16; + PyObject *__pyx_codeobj__18; + PyObject *__pyx_codeobj__20; + PyObject *__pyx_codeobj__22; + PyObject *__pyx_codeobj__24; + PyObject *__pyx_codeobj__27; + PyObject *__pyx_codeobj__29; + PyObject *__pyx_codeobj__31; + PyObject *__pyx_codeobj__33; + PyObject *__pyx_codeobj__34; + PyObject *__pyx_codeobj__36; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_KeyType); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_DSSKey); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_RSAKey); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_RSA1Key); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSAKey); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_DSSCert01Key); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_RSACert01Key); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ED25519_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_3key_SSHKey); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_3key_SSHKey); + Py_CLEAR(clear_module_state->__pyx_kp_b_); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyExportError); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyGenerationError); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyImportError); + Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey_ecdsa_name); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey_export_privkey_file); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey_export_privkey_to_pubkey); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey_export_pubkey_base64); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey_is_private); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey_is_public); + Py_CLEAR(clear_module_state->__pyx_n_s_SSHKey_key_type); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_kp_u__2); + Py_CLEAR(clear_module_state->__pyx_n_s__37); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_b64_cert); + Py_CLEAR(clear_module_state->__pyx_n_s_b64_key); + Py_CLEAR(clear_module_state->__pyx_n_s_b_filepath); + Py_CLEAR(clear_module_state->__pyx_n_s_b_key); + Py_CLEAR(clear_module_state->__pyx_n_s_b_name); + Py_CLEAR(clear_module_state->__pyx_n_s_b_passphrase); + Py_CLEAR(clear_module_state->__pyx_n_s_bits); + Py_CLEAR(clear_module_state->__pyx_n_s_c_filepath); + Py_CLEAR(clear_module_state->__pyx_n_s_c_key); + Py_CLEAR(clear_module_state->__pyx_n_s_c_name); + Py_CLEAR(clear_module_state->__pyx_n_s_c_passphrase); + Py_CLEAR(clear_module_state->__pyx_n_s_cert_key); + Py_CLEAR(clear_module_state->__pyx_n_s_cert_key_2); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_copy_cert_to_privkey); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_n_s_ecdsa_name); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_exceptions); + Py_CLEAR(clear_module_state->__pyx_n_s_export_privkey_file); + Py_CLEAR(clear_module_state->__pyx_n_s_export_privkey_to_pubkey); + Py_CLEAR(clear_module_state->__pyx_n_s_export_pubkey_base64); + Py_CLEAR(clear_module_state->__pyx_n_s_filepath); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_generate); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_import_cert_base64); + Py_CLEAR(clear_module_state->__pyx_n_s_import_cert_file); + Py_CLEAR(clear_module_state->__pyx_n_s_import_privkey_base64); + Py_CLEAR(clear_module_state->__pyx_n_s_import_privkey_file); + Py_CLEAR(clear_module_state->__pyx_n_s_import_pubkey_base64); + Py_CLEAR(clear_module_state->__pyx_n_s_import_pubkey_file); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_n_s_is_private); + Py_CLEAR(clear_module_state->__pyx_n_s_is_public); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_key); + Py_CLEAR(clear_module_state->__pyx_n_s_key_2); + Py_CLEAR(clear_module_state->__pyx_n_s_key_len); + Py_CLEAR(clear_module_state->__pyx_n_s_key_type); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_passphrase); + Py_CLEAR(clear_module_state->__pyx_n_s_priv_key); + Py_CLEAR(clear_module_state->__pyx_n_s_priv_key_2); + Py_CLEAR(clear_module_state->__pyx_n_s_pub_key); + Py_CLEAR(clear_module_state->__pyx_n_s_pub_key_2); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_rc); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_key); + Py_CLEAR(clear_module_state->__pyx_kp_s_ssh_key_pyx); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_type); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__6); + Py_CLEAR(clear_module_state->__pyx_tuple__8); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__12); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_tuple__15); + Py_CLEAR(clear_module_state->__pyx_tuple__17); + Py_CLEAR(clear_module_state->__pyx_tuple__19); + Py_CLEAR(clear_module_state->__pyx_tuple__21); + Py_CLEAR(clear_module_state->__pyx_tuple__23); + Py_CLEAR(clear_module_state->__pyx_tuple__25); + Py_CLEAR(clear_module_state->__pyx_tuple__26); + Py_CLEAR(clear_module_state->__pyx_tuple__28); + Py_CLEAR(clear_module_state->__pyx_tuple__30); + Py_CLEAR(clear_module_state->__pyx_tuple__32); + Py_CLEAR(clear_module_state->__pyx_tuple__35); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__5); + Py_CLEAR(clear_module_state->__pyx_codeobj__7); + Py_CLEAR(clear_module_state->__pyx_codeobj__9); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__14); + Py_CLEAR(clear_module_state->__pyx_codeobj__16); + Py_CLEAR(clear_module_state->__pyx_codeobj__18); + Py_CLEAR(clear_module_state->__pyx_codeobj__20); + Py_CLEAR(clear_module_state->__pyx_codeobj__22); + Py_CLEAR(clear_module_state->__pyx_codeobj__24); + Py_CLEAR(clear_module_state->__pyx_codeobj__27); + Py_CLEAR(clear_module_state->__pyx_codeobj__29); + Py_CLEAR(clear_module_state->__pyx_codeobj__31); + Py_CLEAR(clear_module_state->__pyx_codeobj__33); + Py_CLEAR(clear_module_state->__pyx_codeobj__34); + Py_CLEAR(clear_module_state->__pyx_codeobj__36); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_KeyType); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_DSSKey); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_RSAKey); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_RSA1Key); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSAKey); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_DSSCert01Key); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_RSACert01Key); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ED25519_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_3key_SSHKey); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_3key_SSHKey); + Py_VISIT(traverse_module_state->__pyx_kp_b_); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyExportError); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyGenerationError); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyImportError); + Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey_ecdsa_name); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey_export_privkey_file); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey_export_privkey_to_pubkey); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey_export_pubkey_base64); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey_is_private); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey_is_public); + Py_VISIT(traverse_module_state->__pyx_n_s_SSHKey_key_type); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_kp_u__2); + Py_VISIT(traverse_module_state->__pyx_n_s__37); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_b64_cert); + Py_VISIT(traverse_module_state->__pyx_n_s_b64_key); + Py_VISIT(traverse_module_state->__pyx_n_s_b_filepath); + Py_VISIT(traverse_module_state->__pyx_n_s_b_key); + Py_VISIT(traverse_module_state->__pyx_n_s_b_name); + Py_VISIT(traverse_module_state->__pyx_n_s_b_passphrase); + Py_VISIT(traverse_module_state->__pyx_n_s_bits); + Py_VISIT(traverse_module_state->__pyx_n_s_c_filepath); + Py_VISIT(traverse_module_state->__pyx_n_s_c_key); + Py_VISIT(traverse_module_state->__pyx_n_s_c_name); + Py_VISIT(traverse_module_state->__pyx_n_s_c_passphrase); + Py_VISIT(traverse_module_state->__pyx_n_s_cert_key); + Py_VISIT(traverse_module_state->__pyx_n_s_cert_key_2); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_copy_cert_to_privkey); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_n_s_ecdsa_name); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_exceptions); + Py_VISIT(traverse_module_state->__pyx_n_s_export_privkey_file); + Py_VISIT(traverse_module_state->__pyx_n_s_export_privkey_to_pubkey); + Py_VISIT(traverse_module_state->__pyx_n_s_export_pubkey_base64); + Py_VISIT(traverse_module_state->__pyx_n_s_filepath); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_generate); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_import_cert_base64); + Py_VISIT(traverse_module_state->__pyx_n_s_import_cert_file); + Py_VISIT(traverse_module_state->__pyx_n_s_import_privkey_base64); + Py_VISIT(traverse_module_state->__pyx_n_s_import_privkey_file); + Py_VISIT(traverse_module_state->__pyx_n_s_import_pubkey_base64); + Py_VISIT(traverse_module_state->__pyx_n_s_import_pubkey_file); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_n_s_is_private); + Py_VISIT(traverse_module_state->__pyx_n_s_is_public); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_key); + Py_VISIT(traverse_module_state->__pyx_n_s_key_2); + Py_VISIT(traverse_module_state->__pyx_n_s_key_len); + Py_VISIT(traverse_module_state->__pyx_n_s_key_type); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_passphrase); + Py_VISIT(traverse_module_state->__pyx_n_s_priv_key); + Py_VISIT(traverse_module_state->__pyx_n_s_priv_key_2); + Py_VISIT(traverse_module_state->__pyx_n_s_pub_key); + Py_VISIT(traverse_module_state->__pyx_n_s_pub_key_2); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_rc); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_key); + Py_VISIT(traverse_module_state->__pyx_kp_s_ssh_key_pyx); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_type); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__6); + Py_VISIT(traverse_module_state->__pyx_tuple__8); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__12); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_tuple__15); + Py_VISIT(traverse_module_state->__pyx_tuple__17); + Py_VISIT(traverse_module_state->__pyx_tuple__19); + Py_VISIT(traverse_module_state->__pyx_tuple__21); + Py_VISIT(traverse_module_state->__pyx_tuple__23); + Py_VISIT(traverse_module_state->__pyx_tuple__25); + Py_VISIT(traverse_module_state->__pyx_tuple__26); + Py_VISIT(traverse_module_state->__pyx_tuple__28); + Py_VISIT(traverse_module_state->__pyx_tuple__30); + Py_VISIT(traverse_module_state->__pyx_tuple__32); + Py_VISIT(traverse_module_state->__pyx_tuple__35); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__5); + Py_VISIT(traverse_module_state->__pyx_codeobj__7); + Py_VISIT(traverse_module_state->__pyx_codeobj__9); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__14); + Py_VISIT(traverse_module_state->__pyx_codeobj__16); + Py_VISIT(traverse_module_state->__pyx_codeobj__18); + Py_VISIT(traverse_module_state->__pyx_codeobj__20); + Py_VISIT(traverse_module_state->__pyx_codeobj__22); + Py_VISIT(traverse_module_state->__pyx_codeobj__24); + Py_VISIT(traverse_module_state->__pyx_codeobj__27); + Py_VISIT(traverse_module_state->__pyx_codeobj__29); + Py_VISIT(traverse_module_state->__pyx_codeobj__31); + Py_VISIT(traverse_module_state->__pyx_codeobj__33); + Py_VISIT(traverse_module_state->__pyx_codeobj__34); + Py_VISIT(traverse_module_state->__pyx_codeobj__36); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_3ssh_8keytypes_KeyType __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_KeyType +#define __pyx_ptype_3ssh_8keytypes_DSSKey __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_DSSKey +#define __pyx_ptype_3ssh_8keytypes_RSAKey __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_RSAKey +#define __pyx_ptype_3ssh_8keytypes_RSA1Key __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_RSA1Key +#define __pyx_ptype_3ssh_8keytypes_ECDSAKey __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSAKey +#define __pyx_ptype_3ssh_8keytypes_DSSCert01Key __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_DSSCert01Key +#define __pyx_ptype_3ssh_8keytypes_RSACert01Key __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_RSACert01Key +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P256 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P256 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P384 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P384 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P521 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P521 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 +#define __pyx_ptype_3ssh_8keytypes_ED25519_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ED25519_CERT01 +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_3ssh_3key_SSHKey __pyx_mstate_global->__pyx_type_3ssh_3key_SSHKey +#endif +#define __pyx_ptype_3ssh_3key_SSHKey __pyx_mstate_global->__pyx_ptype_3ssh_3key_SSHKey +#define __pyx_kp_b_ __pyx_mstate_global->__pyx_kp_b_ +#define __pyx_n_s_KeyExportError __pyx_mstate_global->__pyx_n_s_KeyExportError +#define __pyx_n_s_KeyGenerationError __pyx_mstate_global->__pyx_n_s_KeyGenerationError +#define __pyx_n_s_KeyImportError __pyx_mstate_global->__pyx_n_s_KeyImportError +#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError +#define __pyx_n_s_SSHKey __pyx_mstate_global->__pyx_n_s_SSHKey +#define __pyx_n_s_SSHKey___reduce_cython __pyx_mstate_global->__pyx_n_s_SSHKey___reduce_cython +#define __pyx_n_s_SSHKey___setstate_cython __pyx_mstate_global->__pyx_n_s_SSHKey___setstate_cython +#define __pyx_n_s_SSHKey_ecdsa_name __pyx_mstate_global->__pyx_n_s_SSHKey_ecdsa_name +#define __pyx_n_s_SSHKey_export_privkey_file __pyx_mstate_global->__pyx_n_s_SSHKey_export_privkey_file +#define __pyx_n_s_SSHKey_export_privkey_to_pubkey __pyx_mstate_global->__pyx_n_s_SSHKey_export_privkey_to_pubkey +#define __pyx_n_s_SSHKey_export_pubkey_base64 __pyx_mstate_global->__pyx_n_s_SSHKey_export_pubkey_base64 +#define __pyx_n_s_SSHKey_is_private __pyx_mstate_global->__pyx_n_s_SSHKey_is_private +#define __pyx_n_s_SSHKey_is_public __pyx_mstate_global->__pyx_n_s_SSHKey_is_public +#define __pyx_n_s_SSHKey_key_type __pyx_mstate_global->__pyx_n_s_SSHKey_key_type +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 +#define __pyx_n_s__37 __pyx_mstate_global->__pyx_n_s__37 +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_b64_cert __pyx_mstate_global->__pyx_n_s_b64_cert +#define __pyx_n_s_b64_key __pyx_mstate_global->__pyx_n_s_b64_key +#define __pyx_n_s_b_filepath __pyx_mstate_global->__pyx_n_s_b_filepath +#define __pyx_n_s_b_key __pyx_mstate_global->__pyx_n_s_b_key +#define __pyx_n_s_b_name __pyx_mstate_global->__pyx_n_s_b_name +#define __pyx_n_s_b_passphrase __pyx_mstate_global->__pyx_n_s_b_passphrase +#define __pyx_n_s_bits __pyx_mstate_global->__pyx_n_s_bits +#define __pyx_n_s_c_filepath __pyx_mstate_global->__pyx_n_s_c_filepath +#define __pyx_n_s_c_key __pyx_mstate_global->__pyx_n_s_c_key +#define __pyx_n_s_c_name __pyx_mstate_global->__pyx_n_s_c_name +#define __pyx_n_s_c_passphrase __pyx_mstate_global->__pyx_n_s_c_passphrase +#define __pyx_n_s_cert_key __pyx_mstate_global->__pyx_n_s_cert_key +#define __pyx_n_s_cert_key_2 __pyx_mstate_global->__pyx_n_s_cert_key_2 +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_copy_cert_to_privkey __pyx_mstate_global->__pyx_n_s_copy_cert_to_privkey +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_n_s_ecdsa_name __pyx_mstate_global->__pyx_n_s_ecdsa_name +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_exceptions __pyx_mstate_global->__pyx_n_s_exceptions +#define __pyx_n_s_export_privkey_file __pyx_mstate_global->__pyx_n_s_export_privkey_file +#define __pyx_n_s_export_privkey_to_pubkey __pyx_mstate_global->__pyx_n_s_export_privkey_to_pubkey +#define __pyx_n_s_export_pubkey_base64 __pyx_mstate_global->__pyx_n_s_export_pubkey_base64 +#define __pyx_n_s_filepath __pyx_mstate_global->__pyx_n_s_filepath +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_generate __pyx_mstate_global->__pyx_n_s_generate +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_import_cert_base64 __pyx_mstate_global->__pyx_n_s_import_cert_base64 +#define __pyx_n_s_import_cert_file __pyx_mstate_global->__pyx_n_s_import_cert_file +#define __pyx_n_s_import_privkey_base64 __pyx_mstate_global->__pyx_n_s_import_privkey_base64 +#define __pyx_n_s_import_privkey_file __pyx_mstate_global->__pyx_n_s_import_privkey_file +#define __pyx_n_s_import_pubkey_base64 __pyx_mstate_global->__pyx_n_s_import_pubkey_base64 +#define __pyx_n_s_import_pubkey_file __pyx_mstate_global->__pyx_n_s_import_pubkey_file +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_n_s_is_private __pyx_mstate_global->__pyx_n_s_is_private +#define __pyx_n_s_is_public __pyx_mstate_global->__pyx_n_s_is_public +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_key __pyx_mstate_global->__pyx_n_s_key +#define __pyx_n_s_key_2 __pyx_mstate_global->__pyx_n_s_key_2 +#define __pyx_n_s_key_len __pyx_mstate_global->__pyx_n_s_key_len +#define __pyx_n_s_key_type __pyx_mstate_global->__pyx_n_s_key_type +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_passphrase __pyx_mstate_global->__pyx_n_s_passphrase +#define __pyx_n_s_priv_key __pyx_mstate_global->__pyx_n_s_priv_key +#define __pyx_n_s_priv_key_2 __pyx_mstate_global->__pyx_n_s_priv_key_2 +#define __pyx_n_s_pub_key __pyx_mstate_global->__pyx_n_s_pub_key +#define __pyx_n_s_pub_key_2 __pyx_mstate_global->__pyx_n_s_pub_key_2 +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_ssh_key __pyx_mstate_global->__pyx_n_s_ssh_key +#define __pyx_kp_s_ssh_key_pyx __pyx_mstate_global->__pyx_kp_s_ssh_key_pyx +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_type __pyx_mstate_global->__pyx_n_s_type +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6 +#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 +#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 +#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 +#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 +#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23 +#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25 +#define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26 +#define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28 +#define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30 +#define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32 +#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5 +#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 +#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 +#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16 +#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18 +#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20 +#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 +#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 +#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 +#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 +#define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31 +#define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 +#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34 +#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36 +/* #### Code section: module_code ### */ /* "ssh/key.pyx":30 * @@ -1736,7 +3208,7 @@ static struct __pyx_obj_3ssh_3key_SSHKey *__pyx_f_3ssh_3key_6SSHKey_from_ptr(ssh int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("from_ptr", 0); + __Pyx_RefNannySetupContext("from_ptr", 1); /* "ssh/key.pyx":31 * @staticmethod @@ -1746,7 +3218,7 @@ static struct __pyx_obj_3ssh_3key_SSHKey *__pyx_f_3ssh_3key_6SSHKey_from_ptr(ssh * return _key */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_3ssh_3key_SSHKey(((PyTypeObject *)__pyx_ptype_3ssh_3key_SSHKey), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_1)); + __Pyx_GOTREF((PyObject *)__pyx_t_1); __pyx_v__key = ((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_t_1); __pyx_t_1 = 0; @@ -1766,8 +3238,8 @@ static struct __pyx_obj_3ssh_3key_SSHKey *__pyx_f_3ssh_3key_6SSHKey_from_ptr(ssh * * def __cinit__(self): */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v__key)); + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__key); __pyx_r = __pyx_v__key; goto __pyx_L0; @@ -1802,12 +3274,20 @@ static struct __pyx_obj_3ssh_3key_SSHKey *__pyx_f_3ssh_3key_6SSHKey_from_ptr(ssh /* Python wrapper */ static int __pyx_pw_3ssh_3key_6SSHKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_3key_6SSHKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey___cinit__(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -1817,12 +3297,10 @@ static int __pyx_pw_3ssh_3key_6SSHKey_1__cinit__(PyObject *__pyx_v_self, PyObjec static int __pyx_pf_3ssh_3key_6SSHKey___cinit__(struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/key.pyx":36 * @@ -1840,7 +3318,7 @@ static int __pyx_pf_3ssh_3key_6SSHKey___cinit__(struct __pyx_obj_3ssh_3key_SSHKe * raise MemoryError * */ - __pyx_t_1 = ((__pyx_v_self->_key == NULL) != 0); + __pyx_t_1 = (__pyx_v_self->_key == NULL); if (unlikely(__pyx_t_1)) { /* "ssh/key.pyx":38 @@ -1876,7 +3354,6 @@ static int __pyx_pf_3ssh_3key_6SSHKey___cinit__(struct __pyx_obj_3ssh_3key_SSHKe __Pyx_AddTraceback("ssh.key.SSHKey.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1891,8 +3368,10 @@ static int __pyx_pf_3ssh_3key_6SSHKey___cinit__(struct __pyx_obj_3ssh_3key_SSHKe /* Python wrapper */ static void __pyx_pw_3ssh_3key_6SSHKey_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_3ssh_3key_6SSHKey_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_3ssh_3key_6SSHKey_2__dealloc__(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -1900,9 +3379,7 @@ static void __pyx_pw_3ssh_3key_6SSHKey_3__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_3ssh_3key_6SSHKey_2__dealloc__(struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "ssh/key.pyx":41 * @@ -1911,7 +3388,7 @@ static void __pyx_pf_3ssh_3key_6SSHKey_2__dealloc__(struct __pyx_obj_3ssh_3key_S * c_ssh.ssh_key_free(self._key) * self._key = NULL */ - __pyx_t_1 = ((__pyx_v_self->_key != NULL) != 0); + __pyx_t_1 = (__pyx_v_self->_key != NULL); if (__pyx_t_1) { /* "ssh/key.pyx":42 @@ -1950,7 +3427,6 @@ static void __pyx_pf_3ssh_3key_6SSHKey_2__dealloc__(struct __pyx_obj_3ssh_3key_S */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "ssh/key.pyx":45 @@ -1962,12 +3438,40 @@ static void __pyx_pf_3ssh_3key_6SSHKey_2__dealloc__(struct __pyx_obj_3ssh_3key_S */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_5is_private(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_4is_private[] = "SSHKey.is_private(self)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_5is_private(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_5is_private(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_4is_private, "SSHKey.is_private(self)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_5is_private = {"is_private", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_5is_private, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_4is_private}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_5is_private(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("is_private (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("is_private", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_private", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_4is_private(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -1984,7 +3488,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_4is_private(struct __pyx_obj_3ssh_3k int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_private", 0); + __Pyx_RefNannySetupContext("is_private", 1); /* "ssh/key.pyx":47 * def is_private(self): @@ -1996,6 +3500,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_4is_private(struct __pyx_obj_3ssh_3k { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2073,12 +3578,40 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_4is_private(struct __pyx_obj_3ssh_3k */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_7is_public(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_6is_public[] = "SSHKey.is_public(self)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_7is_public(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_7is_public(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_6is_public, "SSHKey.is_public(self)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_7is_public = {"is_public", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_7is_public, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_6is_public}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_7is_public(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("is_public (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("is_public", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_public", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_6is_public(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -2095,7 +3628,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_6is_public(struct __pyx_obj_3ssh_3ke int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_public", 0); + __Pyx_RefNannySetupContext("is_public", 1); /* "ssh/key.pyx":53 * def is_public(self): @@ -2107,6 +3640,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_6is_public(struct __pyx_obj_3ssh_3ke { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2186,12 +3720,14 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_6is_public(struct __pyx_obj_3ssh_3ke /* Python wrapper */ static PyObject *__pyx_pw_3ssh_3key_6SSHKey_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ static PyObject *__pyx_pw_3ssh_3key_6SSHKey_9__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_other), __pyx_ptype_3ssh_3key_SSHKey, 1, "other", 0))) __PYX_ERR(0, 57, __pyx_L1_error) __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_8__eq__(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self), ((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_other)); @@ -2215,7 +3751,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_8__eq__(struct __pyx_obj_3ssh_3key_S int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_RefNannySetupContext("__eq__", 1); /* "ssh/key.pyx":60 * cdef bint is_private @@ -2227,6 +3763,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_8__eq__(struct __pyx_obj_3ssh_3key_S { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2248,7 +3785,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_8__eq__(struct __pyx_obj_3ssh_3key_S * c_ssh.ssh_key_cmp( * self._key, other._key, */ - if ((__pyx_v_is_private != 0)) { + if (__pyx_v_is_private) { /* "ssh/key.pyx":62 * with nogil: @@ -2299,7 +3836,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_8__eq__(struct __pyx_obj_3ssh_3key_S * def key_type(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = (!(__pyx_v_equal != 0)); + __pyx_t_2 = (!__pyx_v_equal); __pyx_t_3 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; @@ -2334,12 +3871,40 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_8__eq__(struct __pyx_obj_3ssh_3key_S */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_11key_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_10key_type[] = "SSHKey.key_type(self)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_11key_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_11key_type(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_10key_type, "SSHKey.key_type(self)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_11key_type = {"key_type", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_11key_type, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_10key_type}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_11key_type(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("key_type (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("key_type", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "key_type", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_10key_type(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -2356,7 +3921,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_10key_type(struct __pyx_obj_3ssh_3ke int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("key_type", 0); + __Pyx_RefNannySetupContext("key_type", 1); /* "ssh/key.pyx":72 * def key_type(self): @@ -2365,7 +3930,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_10key_type(struct __pyx_obj_3ssh_3ke * return * _type = c_ssh.ssh_key_type(self._key) */ - __pyx_t_1 = ((__pyx_v_self->_key == NULL) != 0); + __pyx_t_1 = (__pyx_v_self->_key == NULL); if (__pyx_t_1) { /* "ssh/key.pyx":73 @@ -2439,12 +4004,40 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_10key_type(struct __pyx_obj_3ssh_3ke */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_13ecdsa_name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_12ecdsa_name[] = "SSHKey.ecdsa_name(self)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_13ecdsa_name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_13ecdsa_name(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_12ecdsa_name, "SSHKey.ecdsa_name(self)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_13ecdsa_name = {"ecdsa_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_13ecdsa_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_12ecdsa_name}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_13ecdsa_name(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("ecdsa_name (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("ecdsa_name", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "ecdsa_name", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_12ecdsa_name(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -2462,7 +4055,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_12ecdsa_name(struct __pyx_obj_3ssh_3 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ecdsa_name", 0); + __Pyx_RefNannySetupContext("ecdsa_name", 1); /* "ssh/key.pyx":80 * cdef const_char *c_name @@ -2474,6 +4067,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_12ecdsa_name(struct __pyx_obj_3ssh_3 { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2564,52 +4158,82 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_12ecdsa_name(struct __pyx_obj_3ssh_3 */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_14export_privkey_file[] = "SSHKey.export_privkey_file(self, filepath, passphrase=None)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_14export_privkey_file, "SSHKey.export_privkey_file(self, filepath, passphrase=None)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_15export_privkey_file = {"export_privkey_file", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_14export_privkey_file}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file(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_filepath = 0; PyObject *__pyx_v_passphrase = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("export_privkey_file (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filepath,&__pyx_n_s_passphrase,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filepath,&__pyx_n_s_passphrase,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filepath)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filepath)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_passphrase); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_passphrase); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "export_privkey_file") < 0)) __PYX_ERR(0, 85, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "export_privkey_file") < 0)) __PYX_ERR(0, 85, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -2617,10 +4241,18 @@ static PyObject *__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file(PyObject *__py __pyx_v_filepath = values[0]; __pyx_v_passphrase = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("export_privkey_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 85, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("export_privkey_file", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 85, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.key.SSHKey.export_privkey_file", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -2628,6 +4260,12 @@ static PyObject *__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file(PyObject *__py __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_14export_privkey_file(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self), __pyx_v_filepath, __pyx_v_passphrase); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2643,11 +4281,10 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_14export_privkey_file(struct __pyx_o PyObject *__pyx_t_1 = NULL; const char *__pyx_t_2; int __pyx_t_3; - int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("export_privkey_file", 0); + __Pyx_RefNannySetupContext("export_privkey_file", 1); /* "ssh/key.pyx":87 * def export_privkey_file(self, filepath, passphrase=None): @@ -2692,8 +4329,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_14export_privkey_file(struct __pyx_o * c_passphrase = b_passphrase */ __pyx_t_3 = (__pyx_v_passphrase != Py_None); - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + if (__pyx_t_3) { /* "ssh/key.pyx":92 * cdef int rc @@ -2740,6 +4376,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_14export_privkey_file(struct __pyx_o { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2781,8 +4418,8 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_14export_privkey_file(struct __pyx_o * raise KeyExportError * */ - __pyx_t_4 = ((__pyx_v_rc != SSH_OK) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_3 = (__pyx_v_rc != SSH_OK); + if (unlikely(__pyx_t_3)) { /* "ssh/key.pyx":98 * self._key, c_passphrase, NULL, NULL, c_filepath) @@ -2838,12 +4475,40 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_14export_privkey_file(struct __pyx_o */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_17export_privkey_to_pubkey(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_16export_privkey_to_pubkey[] = "SSHKey.export_privkey_to_pubkey(self)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_17export_privkey_to_pubkey(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_17export_privkey_to_pubkey(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_16export_privkey_to_pubkey, "SSHKey.export_privkey_to_pubkey(self)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_17export_privkey_to_pubkey = {"export_privkey_to_pubkey", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_17export_privkey_to_pubkey, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_16export_privkey_to_pubkey}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_17export_privkey_to_pubkey(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("export_privkey_to_pubkey (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("export_privkey_to_pubkey", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "export_privkey_to_pubkey", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_16export_privkey_to_pubkey(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -2862,7 +4527,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_16export_privkey_to_pubkey(struct __ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("export_privkey_to_pubkey", 0); + __Pyx_RefNannySetupContext("export_privkey_to_pubkey", 1); /* "ssh/key.pyx":104 * cdef c_ssh.ssh_key _pub_key @@ -2874,6 +4539,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_16export_privkey_to_pubkey(struct __ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -2915,7 +4581,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_16export_privkey_to_pubkey(struct __ * raise KeyExportError * pub_key = SSHKey.from_ptr(_pub_key) */ - __pyx_t_1 = ((__pyx_v_rc != SSH_OK) != 0); + __pyx_t_1 = (__pyx_v_rc != SSH_OK); if (unlikely(__pyx_t_1)) { /* "ssh/key.pyx":107 @@ -2960,7 +4626,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_16export_privkey_to_pubkey(struct __ * def export_pubkey_base64(self): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_pub_key)); + __Pyx_INCREF((PyObject *)__pyx_v_pub_key); __pyx_r = ((PyObject *)__pyx_v_pub_key); goto __pyx_L0; @@ -2993,12 +4659,40 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_16export_privkey_to_pubkey(struct __ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_19export_pubkey_base64(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_18export_pubkey_base64[] = "SSHKey.export_pubkey_base64(self)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_19export_pubkey_base64(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_19export_pubkey_base64(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_18export_pubkey_base64, "SSHKey.export_pubkey_base64(self)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_19export_pubkey_base64 = {"export_pubkey_base64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_19export_pubkey_base64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_18export_pubkey_base64}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_19export_pubkey_base64(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("export_pubkey_base64 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("export_pubkey_base64", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "export_pubkey_base64", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_18export_pubkey_base64(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -3017,7 +4711,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_18export_pubkey_base64(struct __pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("export_pubkey_base64", 0); + __Pyx_RefNannySetupContext("export_pubkey_base64", 1); /* "ssh/key.pyx":116 * cdef bytes b_key @@ -3029,6 +4723,7 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_18export_pubkey_base64(struct __pyx_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3050,8 +4745,8 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_18export_pubkey_base64(struct __pyx_ * with gil: * raise KeyExportError */ - __pyx_t_1 = ((__pyx_v_rc != SSH_OK) != 0); - if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_rc != SSH_OK); + if (unlikely(__pyx_t_1)) { /* "ssh/key.pyx":119 * rc = c_ssh.ssh_pki_export_pubkey_base64(self._key, &_key) @@ -3188,17 +4883,45 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_18export_pubkey_base64(struct __pyx_ /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_20__reduce_cython__[] = "SSHKey.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_20__reduce_cython__, "SSHKey.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_21__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_20__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_20__reduce_cython__(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self)); /* function exit code */ @@ -3209,33 +4932,28 @@ static PyObject *__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__(PyObject *__pyx_ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_20__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_3key_SSHKey *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.key.SSHKey.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3245,21 +4963,104 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_20__reduce_cython__(CYTHON_UNUSED st /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_3key_6SSHKey_22__setstate_cython__[] = "SSHKey.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6SSHKey_22__setstate_cython__, "SSHKey.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_3key_6SSHKey_23__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_22__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_22__setstate_cython__(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.key.SSHKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_3key_6SSHKey_22__setstate_cython__(((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3267,33 +5068,28 @@ static PyObject *__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__(PyObject *__py static PyObject *__pyx_pf_3ssh_3key_6SSHKey_22__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.key.SSHKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3310,60 +5106,100 @@ static PyObject *__pyx_pf_3ssh_3key_6SSHKey_22__setstate_cython__(CYTHON_UNUSED */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_1generate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_3key_generate[] = "generate(KeyType key_type, int bits)"; -static PyMethodDef __pyx_mdef_3ssh_3key_1generate = {"generate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_3key_1generate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_3key_generate}; -static PyObject *__pyx_pw_3ssh_3key_1generate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_3key_1generate(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_generate, "generate(KeyType key_type, int bits)"); +static PyMethodDef __pyx_mdef_3ssh_3key_1generate = {"generate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_1generate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_generate}; +static PyObject *__pyx_pw_3ssh_3key_1generate(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_key_type = 0; int __pyx_v_bits; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("generate (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_key_type,&__pyx_n_s_bits,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_key_type,&__pyx_n_s_bits,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key_type)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bits)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bits)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("generate", 1, 2, 2, 1); __PYX_ERR(0, 126, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "generate") < 0)) __PYX_ERR(0, 126, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "generate") < 0)) __PYX_ERR(0, 126, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_key_type = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)values[0]); __pyx_v_bits = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_bits == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L3_error) } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("generate", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 126, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("generate", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 126, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.key.generate", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3376,6 +5212,12 @@ static PyObject *__pyx_pw_3ssh_3key_1generate(PyObject *__pyx_self, PyObject *__ __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3391,7 +5233,7 @@ static PyObject *__pyx_pf_3ssh_3key_generate(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("generate", 0); + __Pyx_RefNannySetupContext("generate", 1); /* "ssh/key.pyx":130 * cdef c_ssh.ssh_key _key @@ -3403,6 +5245,7 @@ static PyObject *__pyx_pf_3ssh_3key_generate(CYTHON_UNUSED PyObject *__pyx_self, { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3444,7 +5287,7 @@ static PyObject *__pyx_pf_3ssh_3key_generate(CYTHON_UNUSED PyObject *__pyx_self, * raise KeyGenerationError * key = SSHKey.from_ptr(_key) */ - __pyx_t_1 = ((__pyx_v_rc != SSH_OK) != 0); + __pyx_t_1 = (__pyx_v_rc != SSH_OK); if (unlikely(__pyx_t_1)) { /* "ssh/key.pyx":133 @@ -3489,7 +5332,7 @@ static PyObject *__pyx_pf_3ssh_3key_generate(CYTHON_UNUSED PyObject *__pyx_self, * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_key)); + __Pyx_INCREF((PyObject *)__pyx_v_key); __pyx_r = ((PyObject *)__pyx_v_key); goto __pyx_L0; @@ -3522,53 +5365,82 @@ static PyObject *__pyx_pf_3ssh_3key_generate(CYTHON_UNUSED PyObject *__pyx_self, */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_3import_privkey_base64(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_3key_2import_privkey_base64[] = "import_privkey_base64(bytes b64_key, passphrase=b'')"; -static PyMethodDef __pyx_mdef_3ssh_3key_3import_privkey_base64 = {"import_privkey_base64", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_3key_3import_privkey_base64, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_3key_2import_privkey_base64}; -static PyObject *__pyx_pw_3ssh_3key_3import_privkey_base64(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_3key_3import_privkey_base64(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_2import_privkey_base64, "import_privkey_base64(bytes b64_key, passphrase=b'')"); +static PyMethodDef __pyx_mdef_3ssh_3key_3import_privkey_base64 = {"import_privkey_base64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_3import_privkey_base64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_2import_privkey_base64}; +static PyObject *__pyx_pw_3ssh_3key_3import_privkey_base64(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_b64_key = 0; PyObject *__pyx_v_passphrase = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("import_privkey_base64 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b64_key,&__pyx_n_s_passphrase,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)__pyx_kp_b__3); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b64_key,&__pyx_n_s_passphrase,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject*)__pyx_kp_b_))); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b64_key)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_b64_key)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 138, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_passphrase); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_passphrase); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 138, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "import_privkey_base64") < 0)) __PYX_ERR(0, 138, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "import_privkey_base64") < 0)) __PYX_ERR(0, 138, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -3576,10 +5448,18 @@ static PyObject *__pyx_pw_3ssh_3key_3import_privkey_base64(PyObject *__pyx_self, __pyx_v_b64_key = ((PyObject*)values[0]); __pyx_v_passphrase = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("import_privkey_base64", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 138, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("import_privkey_base64", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 138, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.key.import_privkey_base64", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3592,6 +5472,12 @@ static PyObject *__pyx_pw_3ssh_3key_3import_privkey_base64(PyObject *__pyx_self, __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3607,12 +5493,11 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec __Pyx_RefNannyDeclarations const char *__pyx_t_1; int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_privkey_base64", 0); + __Pyx_RefNannySetupContext("import_privkey_base64", 1); /* "ssh/key.pyx":139 * @@ -3645,8 +5530,7 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec * c_passphrase = b_passphrase */ __pyx_t_2 = (__pyx_v_passphrase != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { /* "ssh/key.pyx":146 * cdef c_ssh.ssh_key _key @@ -3655,10 +5539,10 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec * c_passphrase = b_passphrase * with nogil: */ - __pyx_t_4 = __pyx_f_3ssh_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v_b_passphrase = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_3 = __pyx_f_3ssh_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_b_passphrase = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; /* "ssh/key.pyx":147 * if passphrase is not None: @@ -3693,6 +5577,7 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -3734,8 +5619,8 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec * raise KeyImportError * key = SSHKey.from_ptr(_key) */ - __pyx_t_3 = ((__pyx_v_rc != SSH_OK) != 0); - if (unlikely(__pyx_t_3)) { + __pyx_t_2 = (__pyx_v_rc != SSH_OK); + if (unlikely(__pyx_t_2)) { /* "ssh/key.pyx":152 * c_key, c_passphrase, NULL, NULL, &_key) @@ -3744,10 +5629,10 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec * key = SSHKey.from_ptr(_key) * return key */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_KeyImportError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KeyImportError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __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, 152, __pyx_L1_error) /* "ssh/key.pyx":151 @@ -3766,10 +5651,10 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec * return key * */ - __pyx_t_4 = ((PyObject *)__pyx_f_3ssh_3key_6SSHKey_from_ptr(__pyx_v__key)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v_key = ((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_3 = ((PyObject *)__pyx_f_3ssh_3key_6SSHKey_from_ptr(__pyx_v__key)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_key = ((struct __pyx_obj_3ssh_3key_SSHKey *)__pyx_t_3); + __pyx_t_3 = 0; /* "ssh/key.pyx":154 * raise KeyImportError @@ -3779,7 +5664,7 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_key)); + __Pyx_INCREF((PyObject *)__pyx_v_key); __pyx_r = ((PyObject *)__pyx_v_key); goto __pyx_L0; @@ -3793,7 +5678,7 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("ssh.key.import_privkey_base64", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -3813,53 +5698,82 @@ static PyObject *__pyx_pf_3ssh_3key_2import_privkey_base64(CYTHON_UNUSED PyObjec */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_5import_privkey_file(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_3key_4import_privkey_file[] = "import_privkey_file(filepath, passphrase=b'')"; -static PyMethodDef __pyx_mdef_3ssh_3key_5import_privkey_file = {"import_privkey_file", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_3key_5import_privkey_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_3key_4import_privkey_file}; -static PyObject *__pyx_pw_3ssh_3key_5import_privkey_file(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_3key_5import_privkey_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_4import_privkey_file, "import_privkey_file(filepath, passphrase=b'')"); +static PyMethodDef __pyx_mdef_3ssh_3key_5import_privkey_file = {"import_privkey_file", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_5import_privkey_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_4import_privkey_file}; +static PyObject *__pyx_pw_3ssh_3key_5import_privkey_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_filepath = 0; PyObject *__pyx_v_passphrase = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("import_privkey_file (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filepath,&__pyx_n_s_passphrase,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)__pyx_kp_b__3); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filepath,&__pyx_n_s_passphrase,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject*)__pyx_kp_b_))); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filepath)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filepath)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 157, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_passphrase); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_passphrase); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 157, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "import_privkey_file") < 0)) __PYX_ERR(0, 157, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "import_privkey_file") < 0)) __PYX_ERR(0, 157, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -3867,10 +5781,18 @@ static PyObject *__pyx_pw_3ssh_3key_5import_privkey_file(PyObject *__pyx_self, P __pyx_v_filepath = values[0]; __pyx_v_passphrase = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("import_privkey_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 157, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("import_privkey_file", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 157, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.key.import_privkey_file", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3878,6 +5800,12 @@ static PyObject *__pyx_pw_3ssh_3key_5import_privkey_file(PyObject *__pyx_self, P __pyx_r = __pyx_pf_3ssh_3key_4import_privkey_file(__pyx_self, __pyx_v_filepath, __pyx_v_passphrase); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3895,11 +5823,10 @@ static PyObject *__pyx_pf_3ssh_3key_4import_privkey_file(CYTHON_UNUSED PyObject PyObject *__pyx_t_1 = NULL; const char *__pyx_t_2; int __pyx_t_3; - int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_privkey_file", 0); + __Pyx_RefNannySetupContext("import_privkey_file", 1); /* "ssh/key.pyx":159 * def import_privkey_file(filepath, passphrase=b''): @@ -3944,8 +5871,7 @@ static PyObject *__pyx_pf_3ssh_3key_4import_privkey_file(CYTHON_UNUSED PyObject * c_passphrase = b_passphrase */ __pyx_t_3 = (__pyx_v_passphrase != Py_None); - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + if (__pyx_t_3) { /* "ssh/key.pyx":166 * cdef c_ssh.ssh_key _key @@ -3992,6 +5918,7 @@ static PyObject *__pyx_pf_3ssh_3key_4import_privkey_file(CYTHON_UNUSED PyObject { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4033,8 +5960,8 @@ static PyObject *__pyx_pf_3ssh_3key_4import_privkey_file(CYTHON_UNUSED PyObject * raise KeyImportError * key = SSHKey.from_ptr(_key) */ - __pyx_t_4 = ((__pyx_v_rc != SSH_OK) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_3 = (__pyx_v_rc != SSH_OK); + if (unlikely(__pyx_t_3)) { /* "ssh/key.pyx":172 * c_filepath, c_passphrase, NULL, NULL, &_key) @@ -4078,7 +6005,7 @@ static PyObject *__pyx_pf_3ssh_3key_4import_privkey_file(CYTHON_UNUSED PyObject * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_key)); + __Pyx_INCREF((PyObject *)__pyx_v_key); __pyx_r = ((PyObject *)__pyx_v_key); goto __pyx_L0; @@ -4113,60 +6040,100 @@ static PyObject *__pyx_pf_3ssh_3key_4import_privkey_file(CYTHON_UNUSED PyObject */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_7import_pubkey_base64(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_3key_6import_pubkey_base64[] = "import_pubkey_base64(bytes b64_key, KeyType key_type)"; -static PyMethodDef __pyx_mdef_3ssh_3key_7import_pubkey_base64 = {"import_pubkey_base64", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_3key_7import_pubkey_base64, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_3key_6import_pubkey_base64}; -static PyObject *__pyx_pw_3ssh_3key_7import_pubkey_base64(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_3key_7import_pubkey_base64(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_6import_pubkey_base64, "import_pubkey_base64(bytes b64_key, KeyType key_type)"); +static PyMethodDef __pyx_mdef_3ssh_3key_7import_pubkey_base64 = {"import_pubkey_base64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_7import_pubkey_base64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6import_pubkey_base64}; +static PyObject *__pyx_pw_3ssh_3key_7import_pubkey_base64(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_b64_key = 0; struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_key_type = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("import_pubkey_base64 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b64_key,&__pyx_n_s_key_type,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b64_key,&__pyx_n_s_key_type,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b64_key)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_b64_key)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 177, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key_type)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 177, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("import_pubkey_base64", 1, 2, 2, 1); __PYX_ERR(0, 177, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "import_pubkey_base64") < 0)) __PYX_ERR(0, 177, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "import_pubkey_base64") < 0)) __PYX_ERR(0, 177, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_b64_key = ((PyObject*)values[0]); __pyx_v_key_type = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)values[1]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("import_pubkey_base64", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 177, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("import_pubkey_base64", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 177, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.key.import_pubkey_base64", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -4180,6 +6147,12 @@ static PyObject *__pyx_pw_3ssh_3key_7import_pubkey_base64(PyObject *__pyx_self, __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4197,7 +6170,7 @@ static PyObject *__pyx_pf_3ssh_3key_6import_pubkey_base64(CYTHON_UNUSED PyObject int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_pubkey_base64", 0); + __Pyx_RefNannySetupContext("import_pubkey_base64", 1); /* "ssh/key.pyx":178 * @@ -4223,6 +6196,7 @@ static PyObject *__pyx_pf_3ssh_3key_6import_pubkey_base64(CYTHON_UNUSED PyObject { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4264,7 +6238,7 @@ static PyObject *__pyx_pf_3ssh_3key_6import_pubkey_base64(CYTHON_UNUSED PyObject * raise KeyImportError * key = SSHKey.from_ptr(_key) */ - __pyx_t_2 = ((__pyx_v_rc != SSH_OK) != 0); + __pyx_t_2 = (__pyx_v_rc != SSH_OK); if (unlikely(__pyx_t_2)) { /* "ssh/key.pyx":186 @@ -4309,7 +6283,7 @@ static PyObject *__pyx_pf_3ssh_3key_6import_pubkey_base64(CYTHON_UNUSED PyObject * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_key)); + __Pyx_INCREF((PyObject *)__pyx_v_key); __pyx_r = ((PyObject *)__pyx_v_key); goto __pyx_L0; @@ -4342,16 +6316,98 @@ static PyObject *__pyx_pf_3ssh_3key_6import_pubkey_base64(CYTHON_UNUSED PyObject */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_9import_pubkey_file(PyObject *__pyx_self, PyObject *__pyx_v_filepath); /*proto*/ -static char __pyx_doc_3ssh_3key_8import_pubkey_file[] = "import_pubkey_file(filepath)"; -static PyMethodDef __pyx_mdef_3ssh_3key_9import_pubkey_file = {"import_pubkey_file", (PyCFunction)__pyx_pw_3ssh_3key_9import_pubkey_file, METH_O, __pyx_doc_3ssh_3key_8import_pubkey_file}; -static PyObject *__pyx_pw_3ssh_3key_9import_pubkey_file(PyObject *__pyx_self, PyObject *__pyx_v_filepath) { +static PyObject *__pyx_pw_3ssh_3key_9import_pubkey_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_8import_pubkey_file, "import_pubkey_file(filepath)"); +static PyMethodDef __pyx_mdef_3ssh_3key_9import_pubkey_file = {"import_pubkey_file", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_9import_pubkey_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_8import_pubkey_file}; +static PyObject *__pyx_pw_3ssh_3key_9import_pubkey_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filepath = 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("import_pubkey_file (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_3key_8import_pubkey_file(__pyx_self, ((PyObject *)__pyx_v_filepath)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filepath,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filepath)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 191, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "import_pubkey_file") < 0)) __PYX_ERR(0, 191, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_filepath = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("import_pubkey_file", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 191, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.key.import_pubkey_file", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_3key_8import_pubkey_file(__pyx_self, __pyx_v_filepath); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4370,7 +6426,7 @@ static PyObject *__pyx_pf_3ssh_3key_8import_pubkey_file(CYTHON_UNUSED PyObject * int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_pubkey_file", 0); + __Pyx_RefNannySetupContext("import_pubkey_file", 1); /* "ssh/key.pyx":192 * @@ -4408,6 +6464,7 @@ static PyObject *__pyx_pf_3ssh_3key_8import_pubkey_file(CYTHON_UNUSED PyObject * { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4449,7 +6506,7 @@ static PyObject *__pyx_pf_3ssh_3key_8import_pubkey_file(CYTHON_UNUSED PyObject * * raise KeyImportError * key = SSHKey.from_ptr(_key) */ - __pyx_t_3 = ((__pyx_v_rc != SSH_OK) != 0); + __pyx_t_3 = (__pyx_v_rc != SSH_OK); if (unlikely(__pyx_t_3)) { /* "ssh/key.pyx":201 @@ -4494,7 +6551,7 @@ static PyObject *__pyx_pf_3ssh_3key_8import_pubkey_file(CYTHON_UNUSED PyObject * * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_key)); + __Pyx_INCREF((PyObject *)__pyx_v_key); __pyx_r = ((PyObject *)__pyx_v_key); goto __pyx_L0; @@ -4528,60 +6585,100 @@ static PyObject *__pyx_pf_3ssh_3key_8import_pubkey_file(CYTHON_UNUSED PyObject * */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_11import_cert_base64(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_3key_10import_cert_base64[] = "import_cert_base64(bytes b64_cert, KeyType key_type)"; -static PyMethodDef __pyx_mdef_3ssh_3key_11import_cert_base64 = {"import_cert_base64", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_3key_11import_cert_base64, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_3key_10import_cert_base64}; -static PyObject *__pyx_pw_3ssh_3key_11import_cert_base64(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_3key_11import_cert_base64(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_10import_cert_base64, "import_cert_base64(bytes b64_cert, KeyType key_type)"); +static PyMethodDef __pyx_mdef_3ssh_3key_11import_cert_base64 = {"import_cert_base64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_11import_cert_base64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_10import_cert_base64}; +static PyObject *__pyx_pw_3ssh_3key_11import_cert_base64(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_b64_cert = 0; struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_key_type = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("import_cert_base64 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b64_cert,&__pyx_n_s_key_type,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b64_cert,&__pyx_n_s_key_type,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b64_cert)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_b64_cert)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key_type)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 206, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("import_cert_base64", 1, 2, 2, 1); __PYX_ERR(0, 206, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "import_cert_base64") < 0)) __PYX_ERR(0, 206, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "import_cert_base64") < 0)) __PYX_ERR(0, 206, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_b64_cert = ((PyObject*)values[0]); __pyx_v_key_type = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)values[1]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("import_cert_base64", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 206, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("import_cert_base64", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 206, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.key.import_cert_base64", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -4595,6 +6692,12 @@ static PyObject *__pyx_pw_3ssh_3key_11import_cert_base64(PyObject *__pyx_self, P __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4612,7 +6715,7 @@ static PyObject *__pyx_pf_3ssh_3key_10import_cert_base64(CYTHON_UNUSED PyObject int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_cert_base64", 0); + __Pyx_RefNannySetupContext("import_cert_base64", 1); /* "ssh/key.pyx":207 * @@ -4638,6 +6741,7 @@ static PyObject *__pyx_pf_3ssh_3key_10import_cert_base64(CYTHON_UNUSED PyObject { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4679,7 +6783,7 @@ static PyObject *__pyx_pf_3ssh_3key_10import_cert_base64(CYTHON_UNUSED PyObject * raise KeyImportError * key = SSHKey.from_ptr(_key) */ - __pyx_t_2 = ((__pyx_v_rc != SSH_OK) != 0); + __pyx_t_2 = (__pyx_v_rc != SSH_OK); if (unlikely(__pyx_t_2)) { /* "ssh/key.pyx":215 @@ -4724,7 +6828,7 @@ static PyObject *__pyx_pf_3ssh_3key_10import_cert_base64(CYTHON_UNUSED PyObject * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_key)); + __Pyx_INCREF((PyObject *)__pyx_v_key); __pyx_r = ((PyObject *)__pyx_v_key); goto __pyx_L0; @@ -4757,16 +6861,98 @@ static PyObject *__pyx_pf_3ssh_3key_10import_cert_base64(CYTHON_UNUSED PyObject */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_13import_cert_file(PyObject *__pyx_self, PyObject *__pyx_v_filepath); /*proto*/ -static char __pyx_doc_3ssh_3key_12import_cert_file[] = "import_cert_file(filepath)"; -static PyMethodDef __pyx_mdef_3ssh_3key_13import_cert_file = {"import_cert_file", (PyCFunction)__pyx_pw_3ssh_3key_13import_cert_file, METH_O, __pyx_doc_3ssh_3key_12import_cert_file}; -static PyObject *__pyx_pw_3ssh_3key_13import_cert_file(PyObject *__pyx_self, PyObject *__pyx_v_filepath) { +static PyObject *__pyx_pw_3ssh_3key_13import_cert_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_12import_cert_file, "import_cert_file(filepath)"); +static PyMethodDef __pyx_mdef_3ssh_3key_13import_cert_file = {"import_cert_file", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_13import_cert_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_12import_cert_file}; +static PyObject *__pyx_pw_3ssh_3key_13import_cert_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filepath = 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("import_cert_file (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_3key_12import_cert_file(__pyx_self, ((PyObject *)__pyx_v_filepath)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filepath,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filepath)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 220, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "import_cert_file") < 0)) __PYX_ERR(0, 220, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_filepath = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("import_cert_file", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 220, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.key.import_cert_file", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_3key_12import_cert_file(__pyx_self, __pyx_v_filepath); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4785,7 +6971,7 @@ static PyObject *__pyx_pf_3ssh_3key_12import_cert_file(CYTHON_UNUSED PyObject *_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_cert_file", 0); + __Pyx_RefNannySetupContext("import_cert_file", 1); /* "ssh/key.pyx":221 * @@ -4823,6 +7009,7 @@ static PyObject *__pyx_pf_3ssh_3key_12import_cert_file(CYTHON_UNUSED PyObject *_ { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -4864,7 +7051,7 @@ static PyObject *__pyx_pf_3ssh_3key_12import_cert_file(CYTHON_UNUSED PyObject *_ * raise KeyImportError * key = SSHKey.from_ptr(_key) */ - __pyx_t_3 = ((__pyx_v_rc != SSH_OK) != 0); + __pyx_t_3 = (__pyx_v_rc != SSH_OK); if (unlikely(__pyx_t_3)) { /* "ssh/key.pyx":230 @@ -4909,7 +7096,7 @@ static PyObject *__pyx_pf_3ssh_3key_12import_cert_file(CYTHON_UNUSED PyObject *_ * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_key)); + __Pyx_INCREF((PyObject *)__pyx_v_key); __pyx_r = ((PyObject *)__pyx_v_key); goto __pyx_L0; @@ -4943,60 +7130,100 @@ static PyObject *__pyx_pf_3ssh_3key_12import_cert_file(CYTHON_UNUSED PyObject *_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_3key_15copy_cert_to_privkey(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_3key_14copy_cert_to_privkey[] = "copy_cert_to_privkey(SSHKey cert_key, SSHKey priv_key)"; -static PyMethodDef __pyx_mdef_3ssh_3key_15copy_cert_to_privkey = {"copy_cert_to_privkey", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_3key_15copy_cert_to_privkey, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_3key_14copy_cert_to_privkey}; -static PyObject *__pyx_pw_3ssh_3key_15copy_cert_to_privkey(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_3key_15copy_cert_to_privkey(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_3key_14copy_cert_to_privkey, "copy_cert_to_privkey(SSHKey cert_key, SSHKey priv_key)"); +static PyMethodDef __pyx_mdef_3ssh_3key_15copy_cert_to_privkey = {"copy_cert_to_privkey", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_15copy_cert_to_privkey, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_14copy_cert_to_privkey}; +static PyObject *__pyx_pw_3ssh_3key_15copy_cert_to_privkey(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_cert_key = 0; struct __pyx_obj_3ssh_3key_SSHKey *__pyx_v_priv_key = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy_cert_to_privkey (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cert_key,&__pyx_n_s_priv_key,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cert_key,&__pyx_n_s_priv_key,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cert_key)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cert_key)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_priv_key)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priv_key)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("copy_cert_to_privkey", 1, 2, 2, 1); __PYX_ERR(0, 235, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "copy_cert_to_privkey") < 0)) __PYX_ERR(0, 235, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "copy_cert_to_privkey") < 0)) __PYX_ERR(0, 235, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_cert_key = ((struct __pyx_obj_3ssh_3key_SSHKey *)values[0]); __pyx_v_priv_key = ((struct __pyx_obj_3ssh_3key_SSHKey *)values[1]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("copy_cert_to_privkey", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 235, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("copy_cert_to_privkey", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 235, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.key.copy_cert_to_privkey", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -5010,6 +7237,12 @@ static PyObject *__pyx_pw_3ssh_3key_15copy_cert_to_privkey(PyObject *__pyx_self, __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5029,7 +7262,7 @@ static PyObject *__pyx_pf_3ssh_3key_14copy_cert_to_privkey(CYTHON_UNUSED PyObjec int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("copy_cert_to_privkey", 0); + __Pyx_RefNannySetupContext("copy_cert_to_privkey", 1); /* "ssh/key.pyx":236 * @@ -5041,23 +7274,29 @@ static PyObject *__pyx_pf_3ssh_3key_14copy_cert_to_privkey(CYTHON_UNUSED PyObjec __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_priv_key), __pyx_n_s_is_private); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; } } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = (__pyx_t_1 == Py_False); + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = (__pyx_t_1 == Py_False); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = (__pyx_t_4 != 0); if (unlikely(__pyx_t_5)) { /* "ssh/key.pyx":237 @@ -5112,6 +7351,7 @@ static PyObject *__pyx_pf_3ssh_3key_14copy_cert_to_privkey(CYTHON_UNUSED PyObjec { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -5152,7 +7392,7 @@ static PyObject *__pyx_pf_3ssh_3key_14copy_cert_to_privkey(CYTHON_UNUSED PyObjec * if rc != c_ssh.SSH_OK: # <<<<<<<<<<<<<< * raise KeyImportError */ - __pyx_t_5 = ((__pyx_v_rc != SSH_OK) != 0); + __pyx_t_5 = (__pyx_v_rc != SSH_OK); if (unlikely(__pyx_t_5)) { /* "ssh/key.pyx":244 @@ -5201,12 +7441,17 @@ static struct __pyx_vtabstruct_3ssh_3key_SSHKey __pyx_vtable_3ssh_3key_SSHKey; static PyObject *__pyx_tp_new_3ssh_3key_SSHKey(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_3ssh_3key_SSHKey *p; PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif p = ((struct __pyx_obj_3ssh_3key_SSHKey *)o); p->__pyx_vtab = __pyx_vtabptr_3ssh_3key_SSHKey; if (unlikely(__pyx_pw_3ssh_3key_6SSHKey_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; @@ -5218,8 +7463,10 @@ static PyObject *__pyx_tp_new_3ssh_3key_SSHKey(PyTypeObject *t, CYTHON_UNUSED Py static void __pyx_tp_dealloc_3ssh_3key_SSHKey(PyObject *o) { #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { - if (PyObject_CallFinalizerFromDealloc(o)) return; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_3ssh_3key_SSHKey) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -5230,7 +7477,14 @@ static void __pyx_tp_dealloc_3ssh_3key_SSHKey(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyObject *__pyx_tp_richcompare_3ssh_3key_SSHKey(PyObject *o1, PyObject *o2, int op) { @@ -5242,7 +7496,8 @@ static PyObject *__pyx_tp_richcompare_3ssh_3key_SSHKey(PyObject *o1, PyObject *o PyObject *ret; ret = __pyx_pw_3ssh_3key_6SSHKey_9__eq__(o1, o2); if (likely(ret && ret != Py_NotImplemented)) { - int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret); + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); if (unlikely(b < 0)) return NULL; ret = (b) ? Py_False : Py_True; Py_INCREF(ret); @@ -5256,21 +7511,37 @@ static PyObject *__pyx_tp_richcompare_3ssh_3key_SSHKey(PyObject *o1, PyObject *o } static PyMethodDef __pyx_methods_3ssh_3key_SSHKey[] = { - {"is_private", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_5is_private, METH_NOARGS, __pyx_doc_3ssh_3key_6SSHKey_4is_private}, - {"is_public", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_7is_public, METH_NOARGS, __pyx_doc_3ssh_3key_6SSHKey_6is_public}, - {"key_type", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_11key_type, METH_NOARGS, __pyx_doc_3ssh_3key_6SSHKey_10key_type}, - {"ecdsa_name", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_13ecdsa_name, METH_NOARGS, __pyx_doc_3ssh_3key_6SSHKey_12ecdsa_name}, - {"export_privkey_file", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_14export_privkey_file}, - {"export_privkey_to_pubkey", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_17export_privkey_to_pubkey, METH_NOARGS, __pyx_doc_3ssh_3key_6SSHKey_16export_privkey_to_pubkey}, - {"export_pubkey_base64", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_19export_pubkey_base64, METH_NOARGS, __pyx_doc_3ssh_3key_6SSHKey_18export_pubkey_base64}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_3key_6SSHKey_20__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__, METH_O, __pyx_doc_3ssh_3key_6SSHKey_22__setstate_cython__}, + {"is_private", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_5is_private, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_4is_private}, + {"is_public", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_7is_public, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_6is_public}, + {"key_type", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_11key_type, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_10key_type}, + {"ecdsa_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_13ecdsa_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_12ecdsa_name}, + {"export_privkey_file", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_15export_privkey_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_14export_privkey_file}, + {"export_privkey_to_pubkey", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_17export_privkey_to_pubkey, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_16export_privkey_to_pubkey}, + {"export_pubkey_base64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_19export_pubkey_base64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_18export_pubkey_base64}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_20__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_3key_6SSHKey_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_3key_6SSHKey_22__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_3key_SSHKey_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_3ssh_3key_SSHKey}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_3ssh_3key_SSHKey}, + {Py_tp_methods, (void *)__pyx_methods_3ssh_3key_SSHKey}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_3key_SSHKey}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_3key_SSHKey_spec = { + "ssh.key.SSHKey", + sizeof(struct __pyx_obj_3ssh_3key_SSHKey), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_3key_SSHKey_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_3key_SSHKey = { PyVarObject_HEAD_INIT(0, 0) - "ssh.key.SSHKey", /*tp_name*/ + "ssh.key.""SSHKey", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_3key_SSHKey), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_3key_SSHKey, /*tp_dealloc*/ @@ -5313,7 +7584,9 @@ static PyTypeObject __pyx_type_3ssh_3key_SSHKey = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_3key_SSHKey, /*tp_new*/ @@ -5327,54 +7600,30 @@ static PyTypeObject __pyx_type_3ssh_3key_SSHKey = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_key(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_key}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "key", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -5384,60 +7633,97 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_KeyExportError, __pyx_k_KeyExportError, sizeof(__pyx_k_KeyExportError), 0, 0, 1, 1}, - {&__pyx_n_s_KeyGenerationError, __pyx_k_KeyGenerationError, sizeof(__pyx_k_KeyGenerationError), 0, 0, 1, 1}, - {&__pyx_n_s_KeyImportError, __pyx_k_KeyImportError, sizeof(__pyx_k_KeyImportError), 0, 0, 1, 1}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_n_s_SSHKey, __pyx_k_SSHKey, sizeof(__pyx_k_SSHKey), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_kp_b__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 0, 0}, - {&__pyx_n_s_b64_cert, __pyx_k_b64_cert, sizeof(__pyx_k_b64_cert), 0, 0, 1, 1}, - {&__pyx_n_s_b64_key, __pyx_k_b64_key, sizeof(__pyx_k_b64_key), 0, 0, 1, 1}, - {&__pyx_n_s_b_filepath, __pyx_k_b_filepath, sizeof(__pyx_k_b_filepath), 0, 0, 1, 1}, - {&__pyx_n_s_b_passphrase, __pyx_k_b_passphrase, sizeof(__pyx_k_b_passphrase), 0, 0, 1, 1}, - {&__pyx_n_s_bits, __pyx_k_bits, sizeof(__pyx_k_bits), 0, 0, 1, 1}, - {&__pyx_n_s_c_filepath, __pyx_k_c_filepath, sizeof(__pyx_k_c_filepath), 0, 0, 1, 1}, - {&__pyx_n_s_c_key, __pyx_k_c_key, sizeof(__pyx_k_c_key), 0, 0, 1, 1}, - {&__pyx_n_s_c_passphrase, __pyx_k_c_passphrase, sizeof(__pyx_k_c_passphrase), 0, 0, 1, 1}, - {&__pyx_n_s_cert_key, __pyx_k_cert_key, sizeof(__pyx_k_cert_key), 0, 0, 1, 1}, - {&__pyx_n_s_cert_key_2, __pyx_k_cert_key_2, sizeof(__pyx_k_cert_key_2), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_copy_cert_to_privkey, __pyx_k_copy_cert_to_privkey, sizeof(__pyx_k_copy_cert_to_privkey), 0, 0, 1, 1}, - {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1}, - {&__pyx_n_s_filepath, __pyx_k_filepath, sizeof(__pyx_k_filepath), 0, 0, 1, 1}, - {&__pyx_n_s_generate, __pyx_k_generate, sizeof(__pyx_k_generate), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_import_cert_base64, __pyx_k_import_cert_base64, sizeof(__pyx_k_import_cert_base64), 0, 0, 1, 1}, - {&__pyx_n_s_import_cert_file, __pyx_k_import_cert_file, sizeof(__pyx_k_import_cert_file), 0, 0, 1, 1}, - {&__pyx_n_s_import_privkey_base64, __pyx_k_import_privkey_base64, sizeof(__pyx_k_import_privkey_base64), 0, 0, 1, 1}, - {&__pyx_n_s_import_privkey_file, __pyx_k_import_privkey_file, sizeof(__pyx_k_import_privkey_file), 0, 0, 1, 1}, - {&__pyx_n_s_import_pubkey_base64, __pyx_k_import_pubkey_base64, sizeof(__pyx_k_import_pubkey_base64), 0, 0, 1, 1}, - {&__pyx_n_s_import_pubkey_file, __pyx_k_import_pubkey_file, sizeof(__pyx_k_import_pubkey_file), 0, 0, 1, 1}, - {&__pyx_n_s_is_private, __pyx_k_is_private, sizeof(__pyx_k_is_private), 0, 0, 1, 1}, - {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, - {&__pyx_n_s_key_2, __pyx_k_key_2, sizeof(__pyx_k_key_2), 0, 0, 1, 1}, - {&__pyx_n_s_key_type, __pyx_k_key_type, sizeof(__pyx_k_key_type), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_passphrase, __pyx_k_passphrase, sizeof(__pyx_k_passphrase), 0, 0, 1, 1}, - {&__pyx_n_s_priv_key, __pyx_k_priv_key, sizeof(__pyx_k_priv_key), 0, 0, 1, 1}, - {&__pyx_n_s_priv_key_2, __pyx_k_priv_key_2, sizeof(__pyx_k_priv_key_2), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_ssh_key, __pyx_k_ssh_key, sizeof(__pyx_k_ssh_key), 0, 0, 1, 1}, - {&__pyx_kp_s_ssh_key_pyx, __pyx_k_ssh_key_pyx, sizeof(__pyx_k_ssh_key_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_b_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 0, 0}, + {&__pyx_n_s_KeyExportError, __pyx_k_KeyExportError, sizeof(__pyx_k_KeyExportError), 0, 0, 1, 1}, + {&__pyx_n_s_KeyGenerationError, __pyx_k_KeyGenerationError, sizeof(__pyx_k_KeyGenerationError), 0, 0, 1, 1}, + {&__pyx_n_s_KeyImportError, __pyx_k_KeyImportError, sizeof(__pyx_k_KeyImportError), 0, 0, 1, 1}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey, __pyx_k_SSHKey, sizeof(__pyx_k_SSHKey), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey___reduce_cython, __pyx_k_SSHKey___reduce_cython, sizeof(__pyx_k_SSHKey___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey___setstate_cython, __pyx_k_SSHKey___setstate_cython, sizeof(__pyx_k_SSHKey___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey_ecdsa_name, __pyx_k_SSHKey_ecdsa_name, sizeof(__pyx_k_SSHKey_ecdsa_name), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey_export_privkey_file, __pyx_k_SSHKey_export_privkey_file, sizeof(__pyx_k_SSHKey_export_privkey_file), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey_export_privkey_to_pubkey, __pyx_k_SSHKey_export_privkey_to_pubkey, sizeof(__pyx_k_SSHKey_export_privkey_to_pubkey), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey_export_pubkey_base64, __pyx_k_SSHKey_export_pubkey_base64, sizeof(__pyx_k_SSHKey_export_pubkey_base64), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey_is_private, __pyx_k_SSHKey_is_private, sizeof(__pyx_k_SSHKey_is_private), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey_is_public, __pyx_k_SSHKey_is_public, sizeof(__pyx_k_SSHKey_is_public), 0, 0, 1, 1}, + {&__pyx_n_s_SSHKey_key_type, __pyx_k_SSHKey_key_type, sizeof(__pyx_k_SSHKey_key_type), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, + {&__pyx_n_s__37, __pyx_k__37, sizeof(__pyx_k__37), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_b64_cert, __pyx_k_b64_cert, sizeof(__pyx_k_b64_cert), 0, 0, 1, 1}, + {&__pyx_n_s_b64_key, __pyx_k_b64_key, sizeof(__pyx_k_b64_key), 0, 0, 1, 1}, + {&__pyx_n_s_b_filepath, __pyx_k_b_filepath, sizeof(__pyx_k_b_filepath), 0, 0, 1, 1}, + {&__pyx_n_s_b_key, __pyx_k_b_key, sizeof(__pyx_k_b_key), 0, 0, 1, 1}, + {&__pyx_n_s_b_name, __pyx_k_b_name, sizeof(__pyx_k_b_name), 0, 0, 1, 1}, + {&__pyx_n_s_b_passphrase, __pyx_k_b_passphrase, sizeof(__pyx_k_b_passphrase), 0, 0, 1, 1}, + {&__pyx_n_s_bits, __pyx_k_bits, sizeof(__pyx_k_bits), 0, 0, 1, 1}, + {&__pyx_n_s_c_filepath, __pyx_k_c_filepath, sizeof(__pyx_k_c_filepath), 0, 0, 1, 1}, + {&__pyx_n_s_c_key, __pyx_k_c_key, sizeof(__pyx_k_c_key), 0, 0, 1, 1}, + {&__pyx_n_s_c_name, __pyx_k_c_name, sizeof(__pyx_k_c_name), 0, 0, 1, 1}, + {&__pyx_n_s_c_passphrase, __pyx_k_c_passphrase, sizeof(__pyx_k_c_passphrase), 0, 0, 1, 1}, + {&__pyx_n_s_cert_key, __pyx_k_cert_key, sizeof(__pyx_k_cert_key), 0, 0, 1, 1}, + {&__pyx_n_s_cert_key_2, __pyx_k_cert_key_2, sizeof(__pyx_k_cert_key_2), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_copy_cert_to_privkey, __pyx_k_copy_cert_to_privkey, sizeof(__pyx_k_copy_cert_to_privkey), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_n_s_ecdsa_name, __pyx_k_ecdsa_name, sizeof(__pyx_k_ecdsa_name), 0, 0, 1, 1}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1}, + {&__pyx_n_s_export_privkey_file, __pyx_k_export_privkey_file, sizeof(__pyx_k_export_privkey_file), 0, 0, 1, 1}, + {&__pyx_n_s_export_privkey_to_pubkey, __pyx_k_export_privkey_to_pubkey, sizeof(__pyx_k_export_privkey_to_pubkey), 0, 0, 1, 1}, + {&__pyx_n_s_export_pubkey_base64, __pyx_k_export_pubkey_base64, sizeof(__pyx_k_export_pubkey_base64), 0, 0, 1, 1}, + {&__pyx_n_s_filepath, __pyx_k_filepath, sizeof(__pyx_k_filepath), 0, 0, 1, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_generate, __pyx_k_generate, sizeof(__pyx_k_generate), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_import_cert_base64, __pyx_k_import_cert_base64, sizeof(__pyx_k_import_cert_base64), 0, 0, 1, 1}, + {&__pyx_n_s_import_cert_file, __pyx_k_import_cert_file, sizeof(__pyx_k_import_cert_file), 0, 0, 1, 1}, + {&__pyx_n_s_import_privkey_base64, __pyx_k_import_privkey_base64, sizeof(__pyx_k_import_privkey_base64), 0, 0, 1, 1}, + {&__pyx_n_s_import_privkey_file, __pyx_k_import_privkey_file, sizeof(__pyx_k_import_privkey_file), 0, 0, 1, 1}, + {&__pyx_n_s_import_pubkey_base64, __pyx_k_import_pubkey_base64, sizeof(__pyx_k_import_pubkey_base64), 0, 0, 1, 1}, + {&__pyx_n_s_import_pubkey_file, __pyx_k_import_pubkey_file, sizeof(__pyx_k_import_pubkey_file), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_n_s_is_private, __pyx_k_is_private, sizeof(__pyx_k_is_private), 0, 0, 1, 1}, + {&__pyx_n_s_is_public, __pyx_k_is_public, sizeof(__pyx_k_is_public), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, + {&__pyx_n_s_key_2, __pyx_k_key_2, sizeof(__pyx_k_key_2), 0, 0, 1, 1}, + {&__pyx_n_s_key_len, __pyx_k_key_len, sizeof(__pyx_k_key_len), 0, 0, 1, 1}, + {&__pyx_n_s_key_type, __pyx_k_key_type, sizeof(__pyx_k_key_type), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_passphrase, __pyx_k_passphrase, sizeof(__pyx_k_passphrase), 0, 0, 1, 1}, + {&__pyx_n_s_priv_key, __pyx_k_priv_key, sizeof(__pyx_k_priv_key), 0, 0, 1, 1}, + {&__pyx_n_s_priv_key_2, __pyx_k_priv_key_2, sizeof(__pyx_k_priv_key_2), 0, 0, 1, 1}, + {&__pyx_n_s_pub_key, __pyx_k_pub_key, sizeof(__pyx_k_pub_key), 0, 0, 1, 1}, + {&__pyx_n_s_pub_key_2, __pyx_k_pub_key_2, sizeof(__pyx_k_pub_key_2), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ssh_key, __pyx_k_ssh_key, sizeof(__pyx_k_ssh_key), 0, 0, 1, 1}, + {&__pyx_kp_s_ssh_key_pyx, __pyx_k_ssh_key_pyx, sizeof(__pyx_k_ssh_key_pyx), 0, 0, 1, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 38, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) @@ -5445,29 +7731,116 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_L1_error:; return -1; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "ssh/key.pyx":45 + * self._key = NULL + * + * def is_private(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); + __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_is_private, 45, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 45, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "ssh/key.pyx":51 + * return bool(rc) + * + * def is_public(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_is_public, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 51, __pyx_L1_error) + + /* "ssh/key.pyx":70 + * return bool(not equal) + * + * def key_type(self): # <<<<<<<<<<<<<< + * cdef c_ssh.ssh_keytypes_e _type + * if self._key is NULL: + */ + __pyx_tuple__6 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_type); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_key_type, 70, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 70, __pyx_L1_error) + + /* "ssh/key.pyx":77 + * return from_keytype(_type) + * + * def ecdsa_name(self): # <<<<<<<<<<<<<< + * cdef const_char *c_name + * cdef bytes b_name + */ + __pyx_tuple__8 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_c_name, __pyx_n_s_b_name); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_ecdsa_name, 77, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 77, __pyx_L1_error) + + /* "ssh/key.pyx":85 + * return to_str(b_name) + * + * def export_privkey_file(self, filepath, passphrase=None): # <<<<<<<<<<<<<< + * cdef bytes b_passphrase + * cdef bytes b_filepath = to_bytes(filepath) + */ + __pyx_tuple__10 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_filepath, __pyx_n_s_passphrase, __pyx_n_s_b_passphrase, __pyx_n_s_b_filepath, __pyx_n_s_c_passphrase, __pyx_n_s_c_filepath, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_export_privkey_file, 85, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_tuple__12 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "ssh/key.pyx":100 + * raise KeyExportError + * + * def export_privkey_to_pubkey(self): # <<<<<<<<<<<<<< + * cdef SSHKey pub_key + * cdef c_ssh.ssh_key _pub_key + */ + __pyx_tuple__13 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_pub_key, __pyx_n_s_pub_key_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_export_privkey_to_pubkey, 100, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 100, __pyx_L1_error) + + /* "ssh/key.pyx":111 + * return pub_key + * + * def export_pubkey_base64(self): # <<<<<<<<<<<<<< + * cdef char *_key + * cdef int rc + */ + __pyx_tuple__15 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_rc, __pyx_n_s_b_key, __pyx_n_s_key_len); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_export_pubkey_base64, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 111, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_tuple__19 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(1, 3, __pyx_L1_error) /* "ssh/key.pyx":126 * @@ -5476,10 +7849,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef SSHKey key * cdef c_ssh.ssh_key _key */ - __pyx_tuple__4 = PyTuple_Pack(5, __pyx_n_s_key_type, __pyx_n_s_bits, __pyx_n_s_key, __pyx_n_s_key_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 126, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_generate, 126, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 126, __pyx_L1_error) + __pyx_tuple__21 = PyTuple_Pack(5, __pyx_n_s_key_type, __pyx_n_s_bits, __pyx_n_s_key_2, __pyx_n_s_key, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_generate, 126, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 126, __pyx_L1_error) /* "ssh/key.pyx":138 * @@ -5488,10 +7861,13 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef const_char *c_key = b64_key * cdef bytes b_passphrase */ - __pyx_tuple__6 = PyTuple_Pack(8, __pyx_n_s_b64_key, __pyx_n_s_passphrase, __pyx_n_s_c_key, __pyx_n_s_b_passphrase, __pyx_n_s_c_passphrase, __pyx_n_s_rc, __pyx_n_s_key, __pyx_n_s_key_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_privkey_base64, 138, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 138, __pyx_L1_error) + __pyx_tuple__23 = PyTuple_Pack(8, __pyx_n_s_b64_key, __pyx_n_s_passphrase, __pyx_n_s_c_key, __pyx_n_s_b_passphrase, __pyx_n_s_c_passphrase, __pyx_n_s_rc, __pyx_n_s_key_2, __pyx_n_s_key); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_privkey_base64, 138, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 138, __pyx_L1_error) + __pyx_tuple__25 = PyTuple_Pack(1, ((PyObject*)__pyx_kp_b_)); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); /* "ssh/key.pyx":157 * @@ -5500,10 +7876,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef bytes b_passphrase * cdef bytes b_filepath = to_bytes(filepath) */ - __pyx_tuple__8 = PyTuple_Pack(9, __pyx_n_s_filepath, __pyx_n_s_passphrase, __pyx_n_s_b_passphrase, __pyx_n_s_b_filepath, __pyx_n_s_c_passphrase, __pyx_n_s_c_filepath, __pyx_n_s_rc, __pyx_n_s_key, __pyx_n_s_key_2); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_privkey_file, 157, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 157, __pyx_L1_error) + __pyx_tuple__26 = PyTuple_Pack(9, __pyx_n_s_filepath, __pyx_n_s_passphrase, __pyx_n_s_b_passphrase, __pyx_n_s_b_filepath, __pyx_n_s_c_passphrase, __pyx_n_s_c_filepath, __pyx_n_s_rc, __pyx_n_s_key_2, __pyx_n_s_key); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_privkey_file, 157, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 157, __pyx_L1_error) /* "ssh/key.pyx":177 * @@ -5512,10 +7888,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef const_char *c_key = b64_key * cdef int rc */ - __pyx_tuple__10 = PyTuple_Pack(6, __pyx_n_s_b64_key, __pyx_n_s_key_type, __pyx_n_s_c_key, __pyx_n_s_rc, __pyx_n_s_key, __pyx_n_s_key_2); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_pubkey_base64, 177, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 177, __pyx_L1_error) + __pyx_tuple__28 = PyTuple_Pack(6, __pyx_n_s_b64_key, __pyx_n_s_key_type, __pyx_n_s_c_key, __pyx_n_s_rc, __pyx_n_s_key_2, __pyx_n_s_key); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_pubkey_base64, 177, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 177, __pyx_L1_error) /* "ssh/key.pyx":191 * @@ -5524,10 +7900,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef bytes b_filepath = to_bytes(filepath) * cdef const_char *c_filepath = b_filepath */ - __pyx_tuple__12 = PyTuple_Pack(6, __pyx_n_s_filepath, __pyx_n_s_b_filepath, __pyx_n_s_c_filepath, __pyx_n_s_rc, __pyx_n_s_key, __pyx_n_s_key_2); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 191, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_pubkey_file, 191, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 191, __pyx_L1_error) + __pyx_tuple__30 = PyTuple_Pack(6, __pyx_n_s_filepath, __pyx_n_s_b_filepath, __pyx_n_s_c_filepath, __pyx_n_s_rc, __pyx_n_s_key_2, __pyx_n_s_key); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_pubkey_file, 191, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 191, __pyx_L1_error) /* "ssh/key.pyx":206 * @@ -5536,10 +7912,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef const_char *c_key = b64_cert * cdef int rc */ - __pyx_tuple__14 = PyTuple_Pack(6, __pyx_n_s_b64_cert, __pyx_n_s_key_type, __pyx_n_s_c_key, __pyx_n_s_rc, __pyx_n_s_key, __pyx_n_s_key_2); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); - __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_cert_base64, 206, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 206, __pyx_L1_error) + __pyx_tuple__32 = PyTuple_Pack(6, __pyx_n_s_b64_cert, __pyx_n_s_key_type, __pyx_n_s_c_key, __pyx_n_s_rc, __pyx_n_s_key_2, __pyx_n_s_key); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); + __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_cert_base64, 206, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 206, __pyx_L1_error) /* "ssh/key.pyx":220 * @@ -5548,10 +7924,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef bytes b_filepath = to_bytes(filepath) * cdef const_char *c_filepath = b_filepath */ - __pyx_tuple__16 = PyTuple_Pack(6, __pyx_n_s_filepath, __pyx_n_s_b_filepath, __pyx_n_s_c_filepath, __pyx_n_s_rc, __pyx_n_s_key, __pyx_n_s_key_2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); - __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_cert_file, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 220, __pyx_L1_error) + __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_import_cert_file, 220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 220, __pyx_L1_error) /* "ssh/key.pyx":235 * @@ -5560,23 +7933,30 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * if priv_key.is_private() is False: * raise KeyImportError */ - __pyx_tuple__18 = PyTuple_Pack(5, __pyx_n_s_cert_key, __pyx_n_s_priv_key, __pyx_n_s_priv_key_2, __pyx_n_s_cert_key_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_copy_cert_to_privkey, 235, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_tuple__35 = PyTuple_Pack(5, __pyx_n_s_cert_key, __pyx_n_s_priv_key, __pyx_n_s_priv_key_2, __pyx_n_s_cert_key_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_key_pyx, __pyx_n_s_copy_cert_to_privkey, 235, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 235, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } +/* #### Code section: init_constants ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -5619,17 +7999,33 @@ static int __Pyx_modinit_type_init_code(void) { /*--- Type init code ---*/ __pyx_vtabptr_3ssh_3key_SSHKey = &__pyx_vtable_3ssh_3key_SSHKey; __pyx_vtable_3ssh_3key_SSHKey.from_ptr = (struct __pyx_obj_3ssh_3key_SSHKey *(*)(ssh_key))__pyx_f_3ssh_3key_6SSHKey_from_ptr; - if (PyType_Ready(&__pyx_type_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_3key_SSHKey.tp_print = 0; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_3ssh_3key_SSHKey = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_3key_SSHKey_spec, NULL); if (unlikely(!__pyx_ptype_3ssh_3key_SSHKey)) __PYX_ERR(0, 27, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_3key_SSHKey_spec, __pyx_ptype_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #else + __pyx_ptype_3ssh_3key_SSHKey = &__pyx_type_3ssh_3key_SSHKey; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_3key_SSHKey.tp_dictoffset && __pyx_type_3ssh_3key_SSHKey.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_3key_SSHKey.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_3key_SSHKey->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_3key_SSHKey->tp_dictoffset && __pyx_ptype_3ssh_3key_SSHKey->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_3key_SSHKey->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_3ssh_3key_SSHKey.tp_dict, __pyx_vtabptr_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SSHKey, (PyObject *)&__pyx_type_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) - __pyx_ptype_3ssh_3key_SSHKey = &__pyx_type_3ssh_3key_SSHKey; + #endif + if (__Pyx_SetVtable(__pyx_ptype_3ssh_3key_SSHKey, __pyx_vtabptr_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SSHKey, (PyObject *) __pyx_ptype_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_3key_SSHKey) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -5647,34 +8043,20 @@ static int __Pyx_modinit_type_import_code(void) { /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule("ssh.keytypes"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_3ssh_8keytypes_KeyType = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "KeyType", sizeof(struct __pyx_obj_3ssh_8keytypes_KeyType), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_KeyType) __PYX_ERR(2, 20, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_DSSKey = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "DSSKey", sizeof(struct __pyx_obj_3ssh_8keytypes_DSSKey), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_DSSKey) __PYX_ERR(2, 24, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_RSAKey = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "RSAKey", sizeof(struct __pyx_obj_3ssh_8keytypes_RSAKey), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_RSAKey) __PYX_ERR(2, 28, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_RSA1Key = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "RSA1Key", sizeof(struct __pyx_obj_3ssh_8keytypes_RSA1Key), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_RSA1Key) __PYX_ERR(2, 32, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ECDSAKey = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ECDSAKey", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSAKey), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ECDSAKey) __PYX_ERR(2, 36, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_DSSCert01Key = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "DSSCert01Key", sizeof(struct __pyx_obj_3ssh_8keytypes_DSSCert01Key), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_DSSCert01Key) __PYX_ERR(2, 40, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_RSACert01Key = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "RSACert01Key", sizeof(struct __pyx_obj_3ssh_8keytypes_RSACert01Key), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_RSACert01Key) __PYX_ERR(2, 44, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ECDSA_P256 = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ECDSA_P256", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P256) __PYX_ERR(2, 48, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ECDSA_P384 = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ECDSA_P384", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P384) __PYX_ERR(2, 52, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ECDSA_P521 = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ECDSA_P521", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P521) __PYX_ERR(2, 56, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ECDSA_P256_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01) __PYX_ERR(2, 60, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ECDSA_P384_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01) __PYX_ERR(2, 64, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ECDSA_P521_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01) __PYX_ERR(2, 68, __pyx_L1_error) - __pyx_ptype_3ssh_8keytypes_ED25519_CERT01 = __Pyx_ImportType(__pyx_t_1, "ssh.keytypes", "ED25519_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_3ssh_8keytypes_ED25519_CERT01) __PYX_ERR(2, 72, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_KeyType = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "KeyType", sizeof(struct __pyx_obj_3ssh_8keytypes_KeyType), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_KeyType),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_KeyType) __PYX_ERR(2, 20, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_DSSKey = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "DSSKey", sizeof(struct __pyx_obj_3ssh_8keytypes_DSSKey), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_DSSKey),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_DSSKey) __PYX_ERR(2, 24, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_RSAKey = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "RSAKey", sizeof(struct __pyx_obj_3ssh_8keytypes_RSAKey), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_RSAKey),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_RSAKey) __PYX_ERR(2, 28, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_RSA1Key = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "RSA1Key", sizeof(struct __pyx_obj_3ssh_8keytypes_RSA1Key), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_RSA1Key),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_RSA1Key) __PYX_ERR(2, 32, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ECDSAKey = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ECDSAKey", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSAKey), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ECDSAKey),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ECDSAKey) __PYX_ERR(2, 36, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_DSSCert01Key = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "DSSCert01Key", sizeof(struct __pyx_obj_3ssh_8keytypes_DSSCert01Key), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_DSSCert01Key),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_DSSCert01Key) __PYX_ERR(2, 40, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_RSACert01Key = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "RSACert01Key", sizeof(struct __pyx_obj_3ssh_8keytypes_RSACert01Key), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_RSACert01Key),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_RSACert01Key) __PYX_ERR(2, 44, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ECDSA_P256 = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ECDSA_P256", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P256) __PYX_ERR(2, 48, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ECDSA_P384 = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ECDSA_P384", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P384) __PYX_ERR(2, 52, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ECDSA_P521 = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ECDSA_P521", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P521) __PYX_ERR(2, 56, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ECDSA_P256_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01) __PYX_ERR(2, 60, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ECDSA_P384_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01) __PYX_ERR(2, 64, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ECDSA_P521_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01) __PYX_ERR(2, 68, __pyx_L1_error) + __pyx_ptype_3ssh_8keytypes_ED25519_CERT01 = __Pyx_ImportType_3_0_10(__pyx_t_1, "ssh.keytypes", "ED25519_CERT01", sizeof(struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_3ssh_8keytypes_ED25519_CERT01) __PYX_ERR(2, 72, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -5702,12 +8084,12 @@ static int __Pyx_modinit_function_import_code(void) { /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("ssh.keytypes"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "from_keytype", (void (**)(void))&__pyx_f_3ssh_8keytypes_from_keytype, "struct __pyx_obj_3ssh_8keytypes_KeyType *(enum ssh_keytypes_e)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "from_keytype", (void (**)(void))&__pyx_f_3ssh_8keytypes_from_keytype, "struct __pyx_obj_3ssh_8keytypes_KeyType *(enum ssh_keytypes_e)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_3ssh_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_3ssh_5utils_to_str, "PyObject *(char const *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_3ssh_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_3ssh_5utils_to_str, "PyObject *(char const *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -5718,6 +8100,55 @@ static int __Pyx_modinit_function_import_code(void) { } +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_key(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_key}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "key", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 @@ -5768,12 +8199,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -5783,8 +8223,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -5794,8 +8235,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -5811,8 +8256,13 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_key(PyObject *__pyx_pyinit_module) #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -5826,6 +8276,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_key(PyObject *__pyx_pyinit_module) #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("key", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "key" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -5836,7 +8313,7 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_key(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif @@ -5844,48 +8321,31 @@ if (!__Pyx_RefNanny) { __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("key", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -5897,7 +8357,7 @@ if (!__Pyx_RefNanny) { { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "ssh.key")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.key", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "ssh.key", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif @@ -5909,10 +8369,10 @@ if (!__Pyx_RefNanny) { (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -5925,33 +8385,146 @@ if (!__Pyx_RefNanny) { * * cimport c_ssh */ - __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_KeyExportError); __Pyx_GIVEREF(__pyx_n_s_KeyExportError); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_KeyExportError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_KeyExportError)) __PYX_ERR(0, 22, __pyx_L1_error); __Pyx_INCREF(__pyx_n_s_KeyImportError); __Pyx_GIVEREF(__pyx_n_s_KeyImportError); - PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_KeyImportError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_KeyImportError)) __PYX_ERR(0, 22, __pyx_L1_error); __Pyx_INCREF(__pyx_n_s_KeyGenerationError); __Pyx_GIVEREF(__pyx_n_s_KeyGenerationError); - PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_KeyGenerationError); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_KeyGenerationError)) __PYX_ERR(0, 22, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_KeyExportError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KeyExportError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExportError, __pyx_t_1) < 0) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KeyImportError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyImportError, __pyx_t_1) < 0) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KeyGenerationError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyGenerationError, __pyx_t_1) < 0) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExportError, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_KeyImportError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyImportError, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_KeyGenerationError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyGenerationError, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "ssh/key.pyx":45 + * self._key = NULL + * + * def is_private(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_5is_private, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey_is_private, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_3key_SSHKey, __pyx_n_s_is_private, __pyx_t_3) < 0) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_3ssh_3key_SSHKey); + + /* "ssh/key.pyx":51 + * return bool(rc) + * + * def is_public(self): # <<<<<<<<<<<<<< + * cdef bint rc + * with nogil: + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_7is_public, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey_is_public, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_3key_SSHKey, __pyx_n_s_is_public, __pyx_t_3) < 0) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_3ssh_3key_SSHKey); + + /* "ssh/key.pyx":70 + * return bool(not equal) + * + * def key_type(self): # <<<<<<<<<<<<<< + * cdef c_ssh.ssh_keytypes_e _type + * if self._key is NULL: + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_11key_type, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey_key_type, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_3key_SSHKey, __pyx_n_s_key_type, __pyx_t_3) < 0) __PYX_ERR(0, 70, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_3ssh_3key_SSHKey); + + /* "ssh/key.pyx":77 + * return from_keytype(_type) + * + * def ecdsa_name(self): # <<<<<<<<<<<<<< + * cdef const_char *c_name + * cdef bytes b_name + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_13ecdsa_name, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey_ecdsa_name, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_3key_SSHKey, __pyx_n_s_ecdsa_name, __pyx_t_3) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_3ssh_3key_SSHKey); + + /* "ssh/key.pyx":85 + * return to_str(b_name) + * + * def export_privkey_file(self, filepath, passphrase=None): # <<<<<<<<<<<<<< + * cdef bytes b_passphrase + * cdef bytes b_filepath = to_bytes(filepath) + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_15export_privkey_file, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey_export_privkey_file, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__12); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_3key_SSHKey, __pyx_n_s_export_privkey_file, __pyx_t_3) < 0) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_3ssh_3key_SSHKey); + + /* "ssh/key.pyx":100 + * raise KeyExportError + * + * def export_privkey_to_pubkey(self): # <<<<<<<<<<<<<< + * cdef SSHKey pub_key + * cdef c_ssh.ssh_key _pub_key + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_17export_privkey_to_pubkey, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey_export_privkey_to_pubkey, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_3key_SSHKey, __pyx_n_s_export_privkey_to_pubkey, __pyx_t_3) < 0) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_3ssh_3key_SSHKey); + + /* "ssh/key.pyx":111 + * return pub_key + * + * def export_pubkey_base64(self): # <<<<<<<<<<<<<< + * cdef char *_key + * cdef int rc + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_19export_pubkey_base64, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey_export_pubkey_base64, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_3ssh_3key_SSHKey, __pyx_n_s_export_pubkey_base64, __pyx_t_3) < 0) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_3ssh_3key_SSHKey); + + /* "(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_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_21__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey___reduce_cython, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "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_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_6SSHKey_23__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SSHKey___setstate_cython, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":126 * @@ -5960,10 +8533,10 @@ if (!__Pyx_RefNanny) { * cdef SSHKey key * cdef c_ssh.ssh_key _key */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_1generate, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_generate, __pyx_t_2) < 0) __PYX_ERR(0, 126, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_1generate, 0, __pyx_n_s_generate, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_generate, __pyx_t_3) < 0) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":138 * @@ -5972,10 +8545,11 @@ if (!__Pyx_RefNanny) { * cdef const_char *c_key = b64_key * cdef bytes b_passphrase */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_3import_privkey_base64, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_privkey_base64, __pyx_t_2) < 0) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_3import_privkey_base64, 0, __pyx_n_s_import_privkey_base64, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__25); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_privkey_base64, __pyx_t_3) < 0) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":157 * @@ -5984,10 +8558,11 @@ if (!__Pyx_RefNanny) { * cdef bytes b_passphrase * cdef bytes b_filepath = to_bytes(filepath) */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_5import_privkey_file, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_privkey_file, __pyx_t_2) < 0) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_5import_privkey_file, 0, __pyx_n_s_import_privkey_file, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__25); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_privkey_file, __pyx_t_3) < 0) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":177 * @@ -5996,10 +8571,10 @@ if (!__Pyx_RefNanny) { * cdef const_char *c_key = b64_key * cdef int rc */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_7import_pubkey_base64, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_pubkey_base64, __pyx_t_2) < 0) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_7import_pubkey_base64, 0, __pyx_n_s_import_pubkey_base64, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_pubkey_base64, __pyx_t_3) < 0) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":191 * @@ -6008,10 +8583,10 @@ if (!__Pyx_RefNanny) { * cdef bytes b_filepath = to_bytes(filepath) * cdef const_char *c_filepath = b_filepath */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_9import_pubkey_file, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_pubkey_file, __pyx_t_2) < 0) __PYX_ERR(0, 191, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_9import_pubkey_file, 0, __pyx_n_s_import_pubkey_file, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_pubkey_file, __pyx_t_3) < 0) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":206 * @@ -6020,10 +8595,10 @@ if (!__Pyx_RefNanny) { * cdef const_char *c_key = b64_cert * cdef int rc */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_11import_cert_base64, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_cert_base64, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_11import_cert_base64, 0, __pyx_n_s_import_cert_base64, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_cert_base64, __pyx_t_3) < 0) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":220 * @@ -6032,10 +8607,10 @@ if (!__Pyx_RefNanny) { * cdef bytes b_filepath = to_bytes(filepath) * cdef const_char *c_filepath = b_filepath */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_13import_cert_file, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_cert_file, __pyx_t_2) < 0) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_13import_cert_file, 0, __pyx_n_s_import_cert_file, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_import_cert_file, __pyx_t_3) < 0) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":235 * @@ -6044,32 +8619,42 @@ if (!__Pyx_RefNanny) { * if priv_key.is_private() is False: * raise KeyImportError */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3ssh_3key_15copy_cert_to_privkey, NULL, __pyx_n_s_ssh_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_copy_cert_to_privkey, __pyx_t_2) < 0) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_3key_15copy_cert_to_privkey, 0, __pyx_n_s_copy_cert_to_privkey, NULL, __pyx_n_s_ssh_key, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_copy_cert_to_privkey, __pyx_t_3) < 0) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "ssh/key.pyx":1 * # This file is part of ssh-python. # <<<<<<<<<<<<<< * # Copyright (C) 2018 Panos Kittenis * # */ - __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); if (__pyx_m) { - if (__pyx_d) { + if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init ssh.key", __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 ssh.key"); } @@ -6083,6 +8668,22 @@ if (!__Pyx_RefNanny) { return; #endif } +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ @@ -6102,6 +8703,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { @@ -6116,10 +8819,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject } #endif +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); @@ -6130,25 +8862,250 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { - Py_ssize_t num_expected; - const char *more_or_less; - if (num_found < num_min) { - num_expected = num_min; - more_or_less = "at least"; - } else { - num_expected = num_max; - more_or_less = "at most"; + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; } - if (exact) { - more_or_less = "exactly"; + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; itp_name, Py_TYPE(obj)->tp_name); + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); return 0; } @@ -6234,6 +9231,7 @@ static void __Pyx_RaiseDoubleKeywordsError( /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, + PyObject *const *kwvalues, PyObject **argnames[], PyObject *kwds2, PyObject *values[], @@ -6244,13 +9242,54 @@ static int __Pyx_ParseOptionalKeywords( Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; - while (PyDict_Next(kwds, &pos, &key, &value)) { + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; continue; } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { @@ -6258,6 +9297,9 @@ static int __Pyx_ParseOptionalKeywords( if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif break; } name++; @@ -6278,14 +9320,18 @@ static int __Pyx_ParseOptionalKeywords( #endif if (likely(PyUnicode_Check(key))) { while (*name) { - int cmp = (**name == key) ? 0 : + int cmp = ( #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif - PyUnicode_Compare(**name, key); + PyUnicode_Compare(**name, key) + ); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif break; } name++; @@ -6312,6 +9358,8 @@ static int __Pyx_ParseOptionalKeywords( goto invalid_keyword; } } + Py_XDECREF(key); + Py_XDECREF(value); return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); @@ -6321,15 +9369,18 @@ static int __Pyx_ParseOptionalKeywords( "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: - PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else + PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: + Py_XDECREF(key); + Py_XDECREF(value); return -1; } @@ -6368,7 +9419,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { @@ -6376,6 +9427,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) } else if (unlikely(PyErr_Occurred())) { return NULL; } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) @@ -6394,35 +9453,11 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) return __Pyx_GetBuiltinName(name); } -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - /* RaiseException */ #if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); Py_XINCREF(type); if (!value || value == Py_None) value = NULL; @@ -6555,13 +9590,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } PyErr_SetObject(type, value); if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else + #if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { @@ -6569,6 +9600,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); #endif } bad: @@ -6577,28 +9614,8 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } #endif -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - /* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; @@ -6627,7 +9644,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args --tstate->recursion_depth; return result; } -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); @@ -6643,9 +9659,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { return NULL; } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && @@ -6714,6 +9736,30 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, return result; } #endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} #endif /* PyObjectCallMethO */ @@ -6721,10 +9767,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { @@ -6736,102 +9787,466 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject } #endif -/* PyObjectCallNoArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); - } -#endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) -#endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); - } - } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); -} -#endif - -/* PyCFunctionFastCall */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; } #endif - -/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); #if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); } #endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (__Pyx_PyFastCFunction_Check(func)) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); } } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); + } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#endif + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: return result; } + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} #endif +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); #endif + __Pyx_DECREF_TypeName(type_name); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { @@ -6872,15 +10287,15 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif - if (!ob) - goto bad; - if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; @@ -6889,58 +10304,85 @@ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { return -1; } -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; itp_dict, __pyx_n_s_pyx_vtable); #endif - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + if (!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; } -#endif -/* PyObjectGetAttrStrNoError */ -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; + { + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; + } } -#endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { + void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); + if (base_vtable != NULL) { + int j; + PyTypeObject* base = type->tp_base; + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = base->tp_base; + } + } } - return result; + PyErr_Clear(); + free(base_vtables); + return 0; +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; } +#endif /* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { @@ -7006,7 +10448,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); @@ -7022,8 +10464,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } goto __PYX_GOOD; __PYX_BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP @@ -7039,18 +10486,21 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { Py_XDECREF(setstate_cython); return ret; } +#endif /* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) +#ifndef __PYX_HAVE_RT_ImportType_3_0_10 +#define __PYX_HAVE_RT_ImportType_3_0_10 +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; -#ifdef Py_LIMITED_API + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; + PyObject *py_itemsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) @@ -7061,8 +10511,9 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, module_name, class_name); goto bad; } -#ifndef Py_LIMITED_API +#if !CYTHON_COMPILING_IN_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) @@ -7072,22 +10523,38 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; #endif - if ((size_t)basicsize < size) { + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + module_name, class_name, size, basicsize+itemsize); goto bad; } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", @@ -7103,39 +10570,32 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *empty_list = 0; PyObject *module = 0; - PyObject *global_dict = 0; PyObject *empty_dict = 0; - PyObject *list; + PyObject *empty_list = 0; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (!py_import) + if (unlikely(!py_import)) goto bad; - #endif - if (from_list) - list = from_list; - else { + if (!from_list) { empty_list = PyList_New(0); - if (!empty_list) + if (unlikely(!empty_list)) goto bad; - list = empty_list; + from_list = empty_list; } - global_dict = PyModule_GetDict(__pyx_m); - if (!global_dict) - goto bad; + #endif empty_dict = PyDict_New(); - if (!empty_dict) + if (unlikely(!empty_dict)) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { - if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, 1); - if (!module) { - if (!PyErr_ExceptionMatches(PyExc_ImportError)) + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } @@ -7146,48 +10606,1255 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); - if (!py_level) + if (unlikely(!py_level)) goto bad; module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); + name, __pyx_d, empty_dict, from_list, level); #endif } } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + return module; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__2); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; } - -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - return value; + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), +#endif + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -7201,7 +11868,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -7223,6 +11890,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -7301,17 +11969,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -7346,6 +12098,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -7361,7 +12114,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -7408,6 +12161,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -7444,7 +12198,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -7458,40 +12212,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -7504,109 +12263,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -7627,6 +12458,22 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { return (int) -1; } +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__37); + } + return name; +} +#endif + /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC @@ -7660,8 +12507,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -7678,7 +12551,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -7692,40 +12565,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -7738,109 +12616,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -7865,7 +12815,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -7886,6 +12836,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -7910,11 +12876,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -7962,47 +12928,56 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionImport */ -#ifndef __PYX_HAVE_RT_ImportFunction -#define __PYX_HAVE_RT_ImportFunction -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { +#ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { @@ -8019,7 +12994,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** PyModule_GetName(module), funcname); goto bad; } -#if PY_VERSION_HEX >= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", @@ -8027,21 +13001,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); -#else - {const char *desc, *s1, *s2; - desc = (const char *)PyCObject_GetDesc(cobj); - if (!desc) - goto bad; - s1 = desc; s2 = sig; - while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } - if (*s1 != *s2) { - PyErr_Format(PyExc_TypeError, - "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", - PyModule_GetName(module), funcname, sig, desc); - goto bad; - } - tmp.p = PyCObject_AsVoidPtr(cobj);} -#endif *f = tmp.fp; if (!(*f)) goto bad; @@ -8054,9 +13013,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** #endif /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -8064,30 +13045,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -8142,7 +13127,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -8171,22 +13156,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -8252,13 +13241,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -8326,4 +13313,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/keytypes.c b/ssh/keytypes.c index 45374d1e..44e50487 100644 --- a/ssh/keytypes.c +++ b/ssh/keytypes.c @@ -1,22 +1,72 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.keytypes", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/keytypes.pyx" + ] + }, + "module_name": "ssh.keytypes" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +85,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +93,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +130,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +150,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +278,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +307,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +318,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +341,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +368,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +392,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +476,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +500,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +517,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +579,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +614,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +766,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +783,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +873,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +919,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +953,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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 + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1047,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1062,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1104,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1121,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1168,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1188,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1228,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -794,9 +1305,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -814,9 +1326,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -824,13 +1336,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -854,12 +1360,58 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; @@ -876,7 +1428,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -906,6 +1458,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -941,23 +1494,26 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { - "stringsource", + "", "ssh/keytypes.pyx", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -965,11 +1521,9 @@ static const char *__pyx_f[] = { #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_3ssh_8keytypes_KeyType; @@ -1181,6 +1735,7 @@ struct __pyx_obj_3ssh_8keytypes_ED25519Key { struct __pyx_obj_3ssh_8keytypes_KeyType __pyx_base; }; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1189,11 +1744,11 @@ struct __pyx_obj_3ssh_8keytypes_ED25519Key { #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1203,28 +1758,40 @@ struct __pyx_obj_3ssh_8keytypes_ED25519Key { #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1235,6 +1802,10 @@ struct __pyx_obj_3ssh_8keytypes_ED25519Key { #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);\ @@ -1246,6 +1817,57 @@ struct __pyx_obj_3ssh_8keytypes_ED25519Key { #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); @@ -1253,45 +1875,116 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif -#if CYTHON_FAST_PYCALL - static size_t __pyx_pyframe_localsplus_offset = 0; +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif // CYTHON_FAST_PYCALL +#endif +#endif #endif /* PyObjectCall.proto */ @@ -1306,61 +1999,49 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); + /* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) -#endif -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); -#else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); #endif -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 @@ -1376,19 +2057,150 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +/* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce(PyObject* type_obj); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); #else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); #endif -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif -/* SetupReduce.proto */ -static int __Pyx_setup_reduce(PyObject* type_obj); +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -1424,6 +2236,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1437,19 +2250,33 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__ssh_keytypes_e(enum ssh_keytypes_e value); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1462,84 +2289,85 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionExport.proto */ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /* FunctionImport.proto */ -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "libc.time" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'libc.string' */ +/* Module declarations from "libc.string" */ -/* Module declarations from 'ssh.utils' */ +/* Module declarations from "ssh.utils" */ static PyObject *(*__pyx_f_3ssh_5utils_to_bytes)(PyObject *); /*proto*/ static PyObject *(*__pyx_f_3ssh_5utils_to_str)(char const *); /*proto*/ -/* Module declarations from 'ssh.keytypes' */ -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_KeyType = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSKey = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSAKey = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSA1Key = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSAKey = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSCert01Key = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSACert01Key = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ED25519_CERT01 = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_UnknownKey = 0; -static PyTypeObject *__pyx_ptype_3ssh_8keytypes_ED25519Key = 0; +/* Module declarations from "ssh.keytypes" */ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keytype(enum ssh_keytypes_e); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.keytypes" extern int __pyx_module_is_main_ssh__keytypes; int __pyx_module_is_main_ssh__keytypes = 0; -/* Implementation of 'ssh.keytypes' */ +/* Implementation of "ssh.keytypes" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_ValueError; +/* #### Code section: string_decls ### */ +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k__37[] = "?"; static const char __pyx_k_str[] = "__str__"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_type[] = "_type"; static const char __pyx_k_DSSKey[] = "DSSKey"; static const char __pyx_k_RSAKey[] = "RSAKey"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_KeyType[] = "KeyType"; static const char __pyx_k_RSA1Key[] = "RSA1Key"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_unknown[] = "unknown"; static const char __pyx_k_ECDSAKey[] = "ECDSAKey"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_key_name[] = "key_name"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_ECDSA_P256[] = "ECDSA_P256"; static const char __pyx_k_ECDSA_P384[] = "ECDSA_P384"; @@ -1551,7 +2379,9 @@ static const char __pyx_k_b_key_name[] = "b_key_name"; static const char __pyx_k_key_name_2[] = "_key_name"; static const char __pyx_k_DSSCert01Key[] = "DSSCert01Key"; static const char __pyx_k_RSACert01Key[] = "RSACert01Key"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_ssh_keytypes[] = "ssh.keytypes"; +static const char __pyx_k_stringsource[] = ""; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_ED25519_CERT01[] = "ED25519_CERT01"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; @@ -1560,48 +2390,43 @@ static const char __pyx_k_ECDSA_P256_CERT01[] = "ECDSA_P256_CERT01"; static const char __pyx_k_ECDSA_P384_CERT01[] = "ECDSA_P384_CERT01"; static const char __pyx_k_ECDSA_P521_CERT01[] = "ECDSA_P521_CERT01"; static const char __pyx_k_Unknown_keytype_s[] = "Unknown keytype %s"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_key_type_from_name[] = "key_type_from_name"; +static const char __pyx_k_DSSKey___reduce_cython[] = "DSSKey.__reduce_cython__"; +static const char __pyx_k_RSAKey___reduce_cython[] = "RSAKey.__reduce_cython__"; +static const char __pyx_k_KeyType___reduce_cython[] = "KeyType.__reduce_cython__"; +static const char __pyx_k_RSA1Key___reduce_cython[] = "RSA1Key.__reduce_cython__"; +static const char __pyx_k_DSSKey___setstate_cython[] = "DSSKey.__setstate_cython__"; +static const char __pyx_k_ECDSAKey___reduce_cython[] = "ECDSAKey.__reduce_cython__"; +static const char __pyx_k_RSAKey___setstate_cython[] = "RSAKey.__setstate_cython__"; +static const char __pyx_k_KeyType___setstate_cython[] = "KeyType.__setstate_cython__"; +static const char __pyx_k_RSA1Key___setstate_cython[] = "RSA1Key.__setstate_cython__"; +static const char __pyx_k_ECDSAKey___setstate_cython[] = "ECDSAKey.__setstate_cython__"; +static const char __pyx_k_ECDSA_P256___reduce_cython[] = "ECDSA_P256.__reduce_cython__"; +static const char __pyx_k_ECDSA_P384___reduce_cython[] = "ECDSA_P384.__reduce_cython__"; +static const char __pyx_k_ECDSA_P521___reduce_cython[] = "ECDSA_P521.__reduce_cython__"; +static const char __pyx_k_ED25519Key___reduce_cython[] = "ED25519Key.__reduce_cython__"; +static const char __pyx_k_UnknownKey___reduce_cython[] = "UnknownKey.__reduce_cython__"; +static const char __pyx_k_DSSCert01Key___reduce_cython[] = "DSSCert01Key.__reduce_cython__"; +static const char __pyx_k_ECDSA_P256___setstate_cython[] = "ECDSA_P256.__setstate_cython__"; +static const char __pyx_k_ECDSA_P384___setstate_cython[] = "ECDSA_P384.__setstate_cython__"; +static const char __pyx_k_ECDSA_P521___setstate_cython[] = "ECDSA_P521.__setstate_cython__"; +static const char __pyx_k_ED25519Key___setstate_cython[] = "ED25519Key.__setstate_cython__"; +static const char __pyx_k_RSACert01Key___reduce_cython[] = "RSACert01Key.__reduce_cython__"; +static const char __pyx_k_UnknownKey___setstate_cython[] = "UnknownKey.__setstate_cython__"; +static const char __pyx_k_DSSCert01Key___setstate_cython[] = "DSSCert01Key.__setstate_cython__"; +static const char __pyx_k_ED25519_CERT01___reduce_cython[] = "ED25519_CERT01.__reduce_cython__"; +static const char __pyx_k_RSACert01Key___setstate_cython[] = "RSACert01Key.__setstate_cython__"; +static const char __pyx_k_ECDSA_P256_CERT01___reduce_cytho[] = "ECDSA_P256_CERT01.__reduce_cython__"; +static const char __pyx_k_ECDSA_P256_CERT01___setstate_cyt[] = "ECDSA_P256_CERT01.__setstate_cython__"; +static const char __pyx_k_ECDSA_P384_CERT01___reduce_cytho[] = "ECDSA_P384_CERT01.__reduce_cython__"; +static const char __pyx_k_ECDSA_P384_CERT01___setstate_cyt[] = "ECDSA_P384_CERT01.__setstate_cython__"; +static const char __pyx_k_ECDSA_P521_CERT01___reduce_cytho[] = "ECDSA_P521_CERT01.__reduce_cython__"; +static const char __pyx_k_ECDSA_P521_CERT01___setstate_cyt[] = "ECDSA_P521_CERT01.__setstate_cython__"; +static const char __pyx_k_ED25519_CERT01___setstate_cython[] = "ED25519_CERT01.__setstate_cython__"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static PyObject *__pyx_n_s_DSSCert01Key; -static PyObject *__pyx_n_s_DSSKey; -static PyObject *__pyx_n_s_ECDSAKey; -static PyObject *__pyx_n_s_ECDSA_P256; -static PyObject *__pyx_n_s_ECDSA_P256_CERT01; -static PyObject *__pyx_n_s_ECDSA_P384; -static PyObject *__pyx_n_s_ECDSA_P384_CERT01; -static PyObject *__pyx_n_s_ECDSA_P521; -static PyObject *__pyx_n_s_ECDSA_P521_CERT01; -static PyObject *__pyx_n_s_ED25519Key; -static PyObject *__pyx_n_s_ED25519_CERT01; -static PyObject *__pyx_n_s_KeyType; -static PyObject *__pyx_n_s_RSA1Key; -static PyObject *__pyx_n_s_RSACert01Key; -static PyObject *__pyx_n_s_RSAKey; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_n_s_UnknownKey; -static PyObject *__pyx_kp_s_Unknown_keytype_s; -static PyObject *__pyx_n_s_ValueError; -static PyObject *__pyx_n_s_b_key_name; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_key_name; -static PyObject *__pyx_n_s_key_name_2; -static PyObject *__pyx_n_s_key_type_from_name; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_ssh_keytypes; -static PyObject *__pyx_kp_s_ssh_keytypes_pyx; -static PyObject *__pyx_n_s_str; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_type; -static PyObject *__pyx_n_s_unknown; +/* #### Code section: decls ### */ static int __pyx_pf_3ssh_8keytypes_7KeyType___cinit__(struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_5value___get__(struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_2__str__(struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_self); /* proto */ @@ -1670,41 +2495,748 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P521_CERT01(PyTypeObject *t, static PyObject *__pyx_tp_new_3ssh_8keytypes_ED25519_CERT01(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_3ssh_8keytypes_UnknownKey(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_3ssh_8keytypes_ED25519Key(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__4; -static PyObject *__pyx_tuple__5; -static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__7; -static PyObject *__pyx_tuple__8; -static PyObject *__pyx_tuple__9; -static PyObject *__pyx_tuple__10; -static PyObject *__pyx_tuple__11; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__13; -static PyObject *__pyx_tuple__14; -static PyObject *__pyx_tuple__15; -static PyObject *__pyx_tuple__16; -static PyObject *__pyx_tuple__17; -static PyObject *__pyx_tuple__18; -static PyObject *__pyx_tuple__19; -static PyObject *__pyx_tuple__20; -static PyObject *__pyx_tuple__21; -static PyObject *__pyx_tuple__22; -static PyObject *__pyx_tuple__23; -static PyObject *__pyx_tuple__24; -static PyObject *__pyx_tuple__25; -static PyObject *__pyx_tuple__26; -static PyObject *__pyx_tuple__27; -static PyObject *__pyx_tuple__28; -static PyObject *__pyx_tuple__29; -static PyObject *__pyx_tuple__30; -static PyObject *__pyx_tuple__31; -static PyObject *__pyx_tuple__32; -static PyObject *__pyx_tuple__33; -static PyObject *__pyx_codeobj__34; -/* Late includes */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_3ssh_8keytypes_KeyType; + PyObject *__pyx_type_3ssh_8keytypes_DSSKey; + PyObject *__pyx_type_3ssh_8keytypes_RSAKey; + PyObject *__pyx_type_3ssh_8keytypes_RSA1Key; + PyObject *__pyx_type_3ssh_8keytypes_ECDSAKey; + PyObject *__pyx_type_3ssh_8keytypes_DSSCert01Key; + PyObject *__pyx_type_3ssh_8keytypes_RSACert01Key; + PyObject *__pyx_type_3ssh_8keytypes_ECDSA_P256; + PyObject *__pyx_type_3ssh_8keytypes_ECDSA_P384; + PyObject *__pyx_type_3ssh_8keytypes_ECDSA_P521; + PyObject *__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01; + PyObject *__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01; + PyObject *__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01; + PyObject *__pyx_type_3ssh_8keytypes_ED25519_CERT01; + PyObject *__pyx_type_3ssh_8keytypes_UnknownKey; + PyObject *__pyx_type_3ssh_8keytypes_ED25519Key; + #endif + PyTypeObject *__pyx_ptype_3ssh_8keytypes_KeyType; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSKey; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSAKey; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSA1Key; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSAKey; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_DSSCert01Key; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_RSACert01Key; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ED25519_CERT01; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_UnknownKey; + PyTypeObject *__pyx_ptype_3ssh_8keytypes_ED25519Key; + PyObject *__pyx_n_s_DSSCert01Key; + PyObject *__pyx_n_s_DSSCert01Key___reduce_cython; + PyObject *__pyx_n_s_DSSCert01Key___setstate_cython; + PyObject *__pyx_n_s_DSSKey; + PyObject *__pyx_n_s_DSSKey___reduce_cython; + PyObject *__pyx_n_s_DSSKey___setstate_cython; + PyObject *__pyx_n_s_ECDSAKey; + PyObject *__pyx_n_s_ECDSAKey___reduce_cython; + PyObject *__pyx_n_s_ECDSAKey___setstate_cython; + PyObject *__pyx_n_s_ECDSA_P256; + PyObject *__pyx_n_s_ECDSA_P256_CERT01; + PyObject *__pyx_n_s_ECDSA_P256_CERT01___reduce_cytho; + PyObject *__pyx_n_s_ECDSA_P256_CERT01___setstate_cyt; + PyObject *__pyx_n_s_ECDSA_P256___reduce_cython; + PyObject *__pyx_n_s_ECDSA_P256___setstate_cython; + PyObject *__pyx_n_s_ECDSA_P384; + PyObject *__pyx_n_s_ECDSA_P384_CERT01; + PyObject *__pyx_n_s_ECDSA_P384_CERT01___reduce_cytho; + PyObject *__pyx_n_s_ECDSA_P384_CERT01___setstate_cyt; + PyObject *__pyx_n_s_ECDSA_P384___reduce_cython; + PyObject *__pyx_n_s_ECDSA_P384___setstate_cython; + PyObject *__pyx_n_s_ECDSA_P521; + PyObject *__pyx_n_s_ECDSA_P521_CERT01; + PyObject *__pyx_n_s_ECDSA_P521_CERT01___reduce_cytho; + PyObject *__pyx_n_s_ECDSA_P521_CERT01___setstate_cyt; + PyObject *__pyx_n_s_ECDSA_P521___reduce_cython; + PyObject *__pyx_n_s_ECDSA_P521___setstate_cython; + PyObject *__pyx_n_s_ED25519Key; + PyObject *__pyx_n_s_ED25519Key___reduce_cython; + PyObject *__pyx_n_s_ED25519Key___setstate_cython; + PyObject *__pyx_n_s_ED25519_CERT01; + PyObject *__pyx_n_s_ED25519_CERT01___reduce_cython; + PyObject *__pyx_n_s_ED25519_CERT01___setstate_cython; + PyObject *__pyx_n_s_KeyType; + PyObject *__pyx_n_s_KeyType___reduce_cython; + PyObject *__pyx_n_s_KeyType___setstate_cython; + PyObject *__pyx_n_s_RSA1Key; + PyObject *__pyx_n_s_RSA1Key___reduce_cython; + PyObject *__pyx_n_s_RSA1Key___setstate_cython; + PyObject *__pyx_n_s_RSACert01Key; + PyObject *__pyx_n_s_RSACert01Key___reduce_cython; + PyObject *__pyx_n_s_RSACert01Key___setstate_cython; + PyObject *__pyx_n_s_RSAKey; + PyObject *__pyx_n_s_RSAKey___reduce_cython; + PyObject *__pyx_n_s_RSAKey___setstate_cython; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s_UnknownKey; + PyObject *__pyx_n_s_UnknownKey___reduce_cython; + PyObject *__pyx_n_s_UnknownKey___setstate_cython; + PyObject *__pyx_kp_s_Unknown_keytype_s; + PyObject *__pyx_n_s_ValueError; + PyObject *__pyx_n_s__37; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_b_key_name; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_key_name; + PyObject *__pyx_n_s_key_name_2; + PyObject *__pyx_n_s_key_type_from_name; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_ssh_keytypes; + PyObject *__pyx_kp_s_ssh_keytypes_pyx; + PyObject *__pyx_n_s_str; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_type; + PyObject *__pyx_n_s_unknown; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__35; + PyObject *__pyx_codeobj__2; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__5; + PyObject *__pyx_codeobj__6; + PyObject *__pyx_codeobj__7; + PyObject *__pyx_codeobj__8; + PyObject *__pyx_codeobj__9; + PyObject *__pyx_codeobj__10; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__12; + PyObject *__pyx_codeobj__13; + PyObject *__pyx_codeobj__14; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__16; + PyObject *__pyx_codeobj__17; + PyObject *__pyx_codeobj__18; + PyObject *__pyx_codeobj__19; + PyObject *__pyx_codeobj__20; + PyObject *__pyx_codeobj__21; + PyObject *__pyx_codeobj__22; + PyObject *__pyx_codeobj__23; + PyObject *__pyx_codeobj__24; + PyObject *__pyx_codeobj__25; + PyObject *__pyx_codeobj__26; + PyObject *__pyx_codeobj__27; + PyObject *__pyx_codeobj__28; + PyObject *__pyx_codeobj__29; + PyObject *__pyx_codeobj__30; + PyObject *__pyx_codeobj__31; + PyObject *__pyx_codeobj__32; + PyObject *__pyx_codeobj__33; + PyObject *__pyx_codeobj__34; + PyObject *__pyx_codeobj__36; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_KeyType); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_KeyType); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_DSSKey); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_DSSKey); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_RSAKey); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_RSAKey); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_RSA1Key); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_RSA1Key); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSAKey); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ECDSAKey); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_DSSCert01Key); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_DSSCert01Key); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_RSACert01Key); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_RSACert01Key); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P256); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P384); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P521); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ED25519_CERT01); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ED25519_CERT01); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_UnknownKey); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_UnknownKey); + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_8keytypes_ED25519Key); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_8keytypes_ED25519Key); + Py_CLEAR(clear_module_state->__pyx_n_s_DSSCert01Key); + Py_CLEAR(clear_module_state->__pyx_n_s_DSSCert01Key___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_DSSCert01Key___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_DSSKey); + Py_CLEAR(clear_module_state->__pyx_n_s_DSSKey___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_DSSKey___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSAKey); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSAKey___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSAKey___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P256); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P256_CERT01); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P256_CERT01___reduce_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P256_CERT01___setstate_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P256___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P256___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P384); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P384_CERT01); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P384_CERT01___reduce_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P384_CERT01___setstate_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P384___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P384___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P521); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P521_CERT01); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P521_CERT01___reduce_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P521_CERT01___setstate_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P521___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ECDSA_P521___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ED25519Key); + Py_CLEAR(clear_module_state->__pyx_n_s_ED25519Key___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ED25519Key___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ED25519_CERT01); + Py_CLEAR(clear_module_state->__pyx_n_s_ED25519_CERT01___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ED25519_CERT01___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyType); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyType___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyType___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_RSA1Key); + Py_CLEAR(clear_module_state->__pyx_n_s_RSA1Key___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_RSA1Key___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_RSACert01Key); + Py_CLEAR(clear_module_state->__pyx_n_s_RSACert01Key___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_RSACert01Key___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_RSAKey); + Py_CLEAR(clear_module_state->__pyx_n_s_RSAKey___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_RSAKey___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s_UnknownKey); + Py_CLEAR(clear_module_state->__pyx_n_s_UnknownKey___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_UnknownKey___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Unknown_keytype_s); + Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); + Py_CLEAR(clear_module_state->__pyx_n_s__37); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_b_key_name); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_key_name); + Py_CLEAR(clear_module_state->__pyx_n_s_key_name_2); + Py_CLEAR(clear_module_state->__pyx_n_s_key_type_from_name); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_keytypes); + Py_CLEAR(clear_module_state->__pyx_kp_s_ssh_keytypes_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_str); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_type); + Py_CLEAR(clear_module_state->__pyx_n_s_unknown); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__35); + Py_CLEAR(clear_module_state->__pyx_codeobj__2); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__5); + Py_CLEAR(clear_module_state->__pyx_codeobj__6); + Py_CLEAR(clear_module_state->__pyx_codeobj__7); + Py_CLEAR(clear_module_state->__pyx_codeobj__8); + Py_CLEAR(clear_module_state->__pyx_codeobj__9); + Py_CLEAR(clear_module_state->__pyx_codeobj__10); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__12); + Py_CLEAR(clear_module_state->__pyx_codeobj__13); + Py_CLEAR(clear_module_state->__pyx_codeobj__14); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__16); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + Py_CLEAR(clear_module_state->__pyx_codeobj__18); + Py_CLEAR(clear_module_state->__pyx_codeobj__19); + Py_CLEAR(clear_module_state->__pyx_codeobj__20); + Py_CLEAR(clear_module_state->__pyx_codeobj__21); + Py_CLEAR(clear_module_state->__pyx_codeobj__22); + Py_CLEAR(clear_module_state->__pyx_codeobj__23); + Py_CLEAR(clear_module_state->__pyx_codeobj__24); + Py_CLEAR(clear_module_state->__pyx_codeobj__25); + Py_CLEAR(clear_module_state->__pyx_codeobj__26); + Py_CLEAR(clear_module_state->__pyx_codeobj__27); + Py_CLEAR(clear_module_state->__pyx_codeobj__28); + Py_CLEAR(clear_module_state->__pyx_codeobj__29); + Py_CLEAR(clear_module_state->__pyx_codeobj__30); + Py_CLEAR(clear_module_state->__pyx_codeobj__31); + Py_CLEAR(clear_module_state->__pyx_codeobj__32); + Py_CLEAR(clear_module_state->__pyx_codeobj__33); + Py_CLEAR(clear_module_state->__pyx_codeobj__34); + Py_CLEAR(clear_module_state->__pyx_codeobj__36); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_KeyType); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_KeyType); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_DSSKey); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_DSSKey); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_RSAKey); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_RSAKey); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_RSA1Key); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_RSA1Key); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSAKey); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ECDSAKey); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_DSSCert01Key); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_DSSCert01Key); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_RSACert01Key); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_RSACert01Key); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P256); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P384); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P521); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ED25519_CERT01); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ED25519_CERT01); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_UnknownKey); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_UnknownKey); + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_8keytypes_ED25519Key); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_8keytypes_ED25519Key); + Py_VISIT(traverse_module_state->__pyx_n_s_DSSCert01Key); + Py_VISIT(traverse_module_state->__pyx_n_s_DSSCert01Key___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_DSSCert01Key___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_DSSKey); + Py_VISIT(traverse_module_state->__pyx_n_s_DSSKey___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_DSSKey___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSAKey); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSAKey___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSAKey___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P256); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P256_CERT01); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P256_CERT01___reduce_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P256_CERT01___setstate_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P256___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P256___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P384); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P384_CERT01); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P384_CERT01___reduce_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P384_CERT01___setstate_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P384___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P384___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P521); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P521_CERT01); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P521_CERT01___reduce_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P521_CERT01___setstate_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P521___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ECDSA_P521___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ED25519Key); + Py_VISIT(traverse_module_state->__pyx_n_s_ED25519Key___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ED25519Key___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ED25519_CERT01); + Py_VISIT(traverse_module_state->__pyx_n_s_ED25519_CERT01___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ED25519_CERT01___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyType); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyType___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyType___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_RSA1Key); + Py_VISIT(traverse_module_state->__pyx_n_s_RSA1Key___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_RSA1Key___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_RSACert01Key); + Py_VISIT(traverse_module_state->__pyx_n_s_RSACert01Key___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_RSACert01Key___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_RSAKey); + Py_VISIT(traverse_module_state->__pyx_n_s_RSAKey___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_RSAKey___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s_UnknownKey); + Py_VISIT(traverse_module_state->__pyx_n_s_UnknownKey___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_UnknownKey___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Unknown_keytype_s); + Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); + Py_VISIT(traverse_module_state->__pyx_n_s__37); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_b_key_name); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_key_name); + Py_VISIT(traverse_module_state->__pyx_n_s_key_name_2); + Py_VISIT(traverse_module_state->__pyx_n_s_key_type_from_name); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_keytypes); + Py_VISIT(traverse_module_state->__pyx_kp_s_ssh_keytypes_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_str); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_type); + Py_VISIT(traverse_module_state->__pyx_n_s_unknown); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__35); + Py_VISIT(traverse_module_state->__pyx_codeobj__2); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__5); + Py_VISIT(traverse_module_state->__pyx_codeobj__6); + Py_VISIT(traverse_module_state->__pyx_codeobj__7); + Py_VISIT(traverse_module_state->__pyx_codeobj__8); + Py_VISIT(traverse_module_state->__pyx_codeobj__9); + Py_VISIT(traverse_module_state->__pyx_codeobj__10); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__12); + Py_VISIT(traverse_module_state->__pyx_codeobj__13); + Py_VISIT(traverse_module_state->__pyx_codeobj__14); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__16); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + Py_VISIT(traverse_module_state->__pyx_codeobj__18); + Py_VISIT(traverse_module_state->__pyx_codeobj__19); + Py_VISIT(traverse_module_state->__pyx_codeobj__20); + Py_VISIT(traverse_module_state->__pyx_codeobj__21); + Py_VISIT(traverse_module_state->__pyx_codeobj__22); + Py_VISIT(traverse_module_state->__pyx_codeobj__23); + Py_VISIT(traverse_module_state->__pyx_codeobj__24); + Py_VISIT(traverse_module_state->__pyx_codeobj__25); + Py_VISIT(traverse_module_state->__pyx_codeobj__26); + Py_VISIT(traverse_module_state->__pyx_codeobj__27); + Py_VISIT(traverse_module_state->__pyx_codeobj__28); + Py_VISIT(traverse_module_state->__pyx_codeobj__29); + Py_VISIT(traverse_module_state->__pyx_codeobj__30); + Py_VISIT(traverse_module_state->__pyx_codeobj__31); + Py_VISIT(traverse_module_state->__pyx_codeobj__32); + Py_VISIT(traverse_module_state->__pyx_codeobj__33); + Py_VISIT(traverse_module_state->__pyx_codeobj__34); + Py_VISIT(traverse_module_state->__pyx_codeobj__36); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_3ssh_8keytypes_KeyType __pyx_mstate_global->__pyx_type_3ssh_8keytypes_KeyType +#define __pyx_type_3ssh_8keytypes_DSSKey __pyx_mstate_global->__pyx_type_3ssh_8keytypes_DSSKey +#define __pyx_type_3ssh_8keytypes_RSAKey __pyx_mstate_global->__pyx_type_3ssh_8keytypes_RSAKey +#define __pyx_type_3ssh_8keytypes_RSA1Key __pyx_mstate_global->__pyx_type_3ssh_8keytypes_RSA1Key +#define __pyx_type_3ssh_8keytypes_ECDSAKey __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ECDSAKey +#define __pyx_type_3ssh_8keytypes_DSSCert01Key __pyx_mstate_global->__pyx_type_3ssh_8keytypes_DSSCert01Key +#define __pyx_type_3ssh_8keytypes_RSACert01Key __pyx_mstate_global->__pyx_type_3ssh_8keytypes_RSACert01Key +#define __pyx_type_3ssh_8keytypes_ECDSA_P256 __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ECDSA_P256 +#define __pyx_type_3ssh_8keytypes_ECDSA_P384 __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ECDSA_P384 +#define __pyx_type_3ssh_8keytypes_ECDSA_P521 __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ECDSA_P521 +#define __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01 __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01 +#define __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01 __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01 +#define __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01 __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01 +#define __pyx_type_3ssh_8keytypes_ED25519_CERT01 __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ED25519_CERT01 +#define __pyx_type_3ssh_8keytypes_UnknownKey __pyx_mstate_global->__pyx_type_3ssh_8keytypes_UnknownKey +#define __pyx_type_3ssh_8keytypes_ED25519Key __pyx_mstate_global->__pyx_type_3ssh_8keytypes_ED25519Key +#endif +#define __pyx_ptype_3ssh_8keytypes_KeyType __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_KeyType +#define __pyx_ptype_3ssh_8keytypes_DSSKey __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_DSSKey +#define __pyx_ptype_3ssh_8keytypes_RSAKey __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_RSAKey +#define __pyx_ptype_3ssh_8keytypes_RSA1Key __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_RSA1Key +#define __pyx_ptype_3ssh_8keytypes_ECDSAKey __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSAKey +#define __pyx_ptype_3ssh_8keytypes_DSSCert01Key __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_DSSCert01Key +#define __pyx_ptype_3ssh_8keytypes_RSACert01Key __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_RSACert01Key +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P256 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P256 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P384 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P384 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P521 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P521 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 +#define __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 +#define __pyx_ptype_3ssh_8keytypes_ED25519_CERT01 __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ED25519_CERT01 +#define __pyx_ptype_3ssh_8keytypes_UnknownKey __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_UnknownKey +#define __pyx_ptype_3ssh_8keytypes_ED25519Key __pyx_mstate_global->__pyx_ptype_3ssh_8keytypes_ED25519Key +#define __pyx_n_s_DSSCert01Key __pyx_mstate_global->__pyx_n_s_DSSCert01Key +#define __pyx_n_s_DSSCert01Key___reduce_cython __pyx_mstate_global->__pyx_n_s_DSSCert01Key___reduce_cython +#define __pyx_n_s_DSSCert01Key___setstate_cython __pyx_mstate_global->__pyx_n_s_DSSCert01Key___setstate_cython +#define __pyx_n_s_DSSKey __pyx_mstate_global->__pyx_n_s_DSSKey +#define __pyx_n_s_DSSKey___reduce_cython __pyx_mstate_global->__pyx_n_s_DSSKey___reduce_cython +#define __pyx_n_s_DSSKey___setstate_cython __pyx_mstate_global->__pyx_n_s_DSSKey___setstate_cython +#define __pyx_n_s_ECDSAKey __pyx_mstate_global->__pyx_n_s_ECDSAKey +#define __pyx_n_s_ECDSAKey___reduce_cython __pyx_mstate_global->__pyx_n_s_ECDSAKey___reduce_cython +#define __pyx_n_s_ECDSAKey___setstate_cython __pyx_mstate_global->__pyx_n_s_ECDSAKey___setstate_cython +#define __pyx_n_s_ECDSA_P256 __pyx_mstate_global->__pyx_n_s_ECDSA_P256 +#define __pyx_n_s_ECDSA_P256_CERT01 __pyx_mstate_global->__pyx_n_s_ECDSA_P256_CERT01 +#define __pyx_n_s_ECDSA_P256_CERT01___reduce_cytho __pyx_mstate_global->__pyx_n_s_ECDSA_P256_CERT01___reduce_cytho +#define __pyx_n_s_ECDSA_P256_CERT01___setstate_cyt __pyx_mstate_global->__pyx_n_s_ECDSA_P256_CERT01___setstate_cyt +#define __pyx_n_s_ECDSA_P256___reduce_cython __pyx_mstate_global->__pyx_n_s_ECDSA_P256___reduce_cython +#define __pyx_n_s_ECDSA_P256___setstate_cython __pyx_mstate_global->__pyx_n_s_ECDSA_P256___setstate_cython +#define __pyx_n_s_ECDSA_P384 __pyx_mstate_global->__pyx_n_s_ECDSA_P384 +#define __pyx_n_s_ECDSA_P384_CERT01 __pyx_mstate_global->__pyx_n_s_ECDSA_P384_CERT01 +#define __pyx_n_s_ECDSA_P384_CERT01___reduce_cytho __pyx_mstate_global->__pyx_n_s_ECDSA_P384_CERT01___reduce_cytho +#define __pyx_n_s_ECDSA_P384_CERT01___setstate_cyt __pyx_mstate_global->__pyx_n_s_ECDSA_P384_CERT01___setstate_cyt +#define __pyx_n_s_ECDSA_P384___reduce_cython __pyx_mstate_global->__pyx_n_s_ECDSA_P384___reduce_cython +#define __pyx_n_s_ECDSA_P384___setstate_cython __pyx_mstate_global->__pyx_n_s_ECDSA_P384___setstate_cython +#define __pyx_n_s_ECDSA_P521 __pyx_mstate_global->__pyx_n_s_ECDSA_P521 +#define __pyx_n_s_ECDSA_P521_CERT01 __pyx_mstate_global->__pyx_n_s_ECDSA_P521_CERT01 +#define __pyx_n_s_ECDSA_P521_CERT01___reduce_cytho __pyx_mstate_global->__pyx_n_s_ECDSA_P521_CERT01___reduce_cytho +#define __pyx_n_s_ECDSA_P521_CERT01___setstate_cyt __pyx_mstate_global->__pyx_n_s_ECDSA_P521_CERT01___setstate_cyt +#define __pyx_n_s_ECDSA_P521___reduce_cython __pyx_mstate_global->__pyx_n_s_ECDSA_P521___reduce_cython +#define __pyx_n_s_ECDSA_P521___setstate_cython __pyx_mstate_global->__pyx_n_s_ECDSA_P521___setstate_cython +#define __pyx_n_s_ED25519Key __pyx_mstate_global->__pyx_n_s_ED25519Key +#define __pyx_n_s_ED25519Key___reduce_cython __pyx_mstate_global->__pyx_n_s_ED25519Key___reduce_cython +#define __pyx_n_s_ED25519Key___setstate_cython __pyx_mstate_global->__pyx_n_s_ED25519Key___setstate_cython +#define __pyx_n_s_ED25519_CERT01 __pyx_mstate_global->__pyx_n_s_ED25519_CERT01 +#define __pyx_n_s_ED25519_CERT01___reduce_cython __pyx_mstate_global->__pyx_n_s_ED25519_CERT01___reduce_cython +#define __pyx_n_s_ED25519_CERT01___setstate_cython __pyx_mstate_global->__pyx_n_s_ED25519_CERT01___setstate_cython +#define __pyx_n_s_KeyType __pyx_mstate_global->__pyx_n_s_KeyType +#define __pyx_n_s_KeyType___reduce_cython __pyx_mstate_global->__pyx_n_s_KeyType___reduce_cython +#define __pyx_n_s_KeyType___setstate_cython __pyx_mstate_global->__pyx_n_s_KeyType___setstate_cython +#define __pyx_n_s_RSA1Key __pyx_mstate_global->__pyx_n_s_RSA1Key +#define __pyx_n_s_RSA1Key___reduce_cython __pyx_mstate_global->__pyx_n_s_RSA1Key___reduce_cython +#define __pyx_n_s_RSA1Key___setstate_cython __pyx_mstate_global->__pyx_n_s_RSA1Key___setstate_cython +#define __pyx_n_s_RSACert01Key __pyx_mstate_global->__pyx_n_s_RSACert01Key +#define __pyx_n_s_RSACert01Key___reduce_cython __pyx_mstate_global->__pyx_n_s_RSACert01Key___reduce_cython +#define __pyx_n_s_RSACert01Key___setstate_cython __pyx_mstate_global->__pyx_n_s_RSACert01Key___setstate_cython +#define __pyx_n_s_RSAKey __pyx_mstate_global->__pyx_n_s_RSAKey +#define __pyx_n_s_RSAKey___reduce_cython __pyx_mstate_global->__pyx_n_s_RSAKey___reduce_cython +#define __pyx_n_s_RSAKey___setstate_cython __pyx_mstate_global->__pyx_n_s_RSAKey___setstate_cython +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s_UnknownKey __pyx_mstate_global->__pyx_n_s_UnknownKey +#define __pyx_n_s_UnknownKey___reduce_cython __pyx_mstate_global->__pyx_n_s_UnknownKey___reduce_cython +#define __pyx_n_s_UnknownKey___setstate_cython __pyx_mstate_global->__pyx_n_s_UnknownKey___setstate_cython +#define __pyx_kp_s_Unknown_keytype_s __pyx_mstate_global->__pyx_kp_s_Unknown_keytype_s +#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError +#define __pyx_n_s__37 __pyx_mstate_global->__pyx_n_s__37 +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_b_key_name __pyx_mstate_global->__pyx_n_s_b_key_name +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_key_name __pyx_mstate_global->__pyx_n_s_key_name +#define __pyx_n_s_key_name_2 __pyx_mstate_global->__pyx_n_s_key_name_2 +#define __pyx_n_s_key_type_from_name __pyx_mstate_global->__pyx_n_s_key_type_from_name +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_ssh_keytypes __pyx_mstate_global->__pyx_n_s_ssh_keytypes +#define __pyx_kp_s_ssh_keytypes_pyx __pyx_mstate_global->__pyx_kp_s_ssh_keytypes_pyx +#define __pyx_n_s_str __pyx_mstate_global->__pyx_n_s_str +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_type __pyx_mstate_global->__pyx_n_s_type +#define __pyx_n_s_unknown __pyx_mstate_global->__pyx_n_s_unknown +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35 +#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5 +#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 +#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 +#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8 +#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9 +#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12 +#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13 +#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18 +#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 +#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20 +#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 +#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 +#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 +#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 +#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25 +#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26 +#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 +#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28 +#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 +#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30 +#define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31 +#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32 +#define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 +#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34 +#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36 +/* #### Code section: module_code ### */ /* "ssh/keytypes.pyx":25 * @@ -1717,12 +3249,20 @@ static PyObject *__pyx_codeobj__34; /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_7KeyType_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_7KeyType_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_7KeyType___cinit__(((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_v_self)); /* function exit code */ @@ -1732,8 +3272,6 @@ static int __pyx_pw_3ssh_8keytypes_7KeyType_1__cinit__(PyObject *__pyx_v_self, P static int __pyx_pf_3ssh_8keytypes_7KeyType___cinit__(struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":26 * cdef class KeyType: @@ -1754,24 +3292,25 @@ static int __pyx_pf_3ssh_8keytypes_7KeyType___cinit__(struct __pyx_obj_3ssh_8key /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "ssh/keytypes.pyx":29 +/* "ssh/keytypes.pyx":28 + * self._type = ssh_keytypes_e.SSH_KEYTYPE_UNKNOWN * - * @property - * def value(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def value(self): * return self._type - * */ /* Python wrapper */ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_5value_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_5value_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_3ssh_8keytypes_7KeyType_5value___get__(((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_v_self)); /* function exit code */ @@ -1786,7 +3325,7 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_5value___get__(struct __pyx_ob int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "ssh/keytypes.pyx":30 * @property @@ -1802,12 +3341,12 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_5value___get__(struct __pyx_ob __pyx_t_1 = 0; goto __pyx_L0; - /* "ssh/keytypes.pyx":29 + /* "ssh/keytypes.pyx":28 + * self._type = ssh_keytypes_e.SSH_KEYTYPE_UNKNOWN * - * @property - * def value(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def value(self): * return self._type - * */ /* function exit code */ @@ -1832,9 +3371,11 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_5value___get__(struct __pyx_ob /* Python wrapper */ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_3__str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_3ssh_8keytypes_7KeyType_2__str__(((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_v_self)); /* function exit code */ @@ -1851,7 +3392,7 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_2__str__(struct __pyx_obj_3ssh int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_RefNannySetupContext("__str__", 1); /* "ssh/keytypes.pyx":34 * def __str__(self): @@ -1869,7 +3410,7 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_2__str__(struct __pyx_obj_3ssh * return to_str(c_type) * return "unknown" */ - __pyx_t_1 = ((__pyx_v_c_type != NULL) != 0); + __pyx_t_1 = (__pyx_v_c_type != NULL); if (__pyx_t_1) { /* "ssh/keytypes.pyx":36 @@ -1937,9 +3478,11 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_2__str__(struct __pyx_obj_3ssh /* Python wrapper */ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_5__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_3ssh_8keytypes_7KeyType_4__repr__(((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_v_self)); /* function exit code */ @@ -1953,10 +3496,11 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_4__repr__(struct __pyx_obj_3ss PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_RefNannySetupContext("__repr__", 1); /* "ssh/keytypes.pyx":40 * @@ -1969,20 +3513,27 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_4__repr__(struct __pyx_obj_3ss __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; } } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -2010,17 +3561,45 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_4__repr__(struct __pyx_obj_3ss /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_7KeyType_6__reduce_cython__[] = "KeyType.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_7KeyType_6__reduce_cython__, "KeyType.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_7KeyType_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7KeyType_6__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_7KeyType_6__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_v_self)); /* function exit code */ @@ -2031,33 +3610,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__(PyObject *_ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_KeyType *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.KeyType.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2067,21 +3641,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_6__reduce_cython__(CYTHON_UNUS /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_7KeyType_8__setstate_cython__[] = "KeyType.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_7KeyType_8__setstate_cython__, "KeyType.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_7KeyType_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7KeyType_8__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_7KeyType_8__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.KeyType.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_7KeyType_8__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2089,33 +3746,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__(PyObject static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.KeyType.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2134,12 +3786,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7KeyType_8__setstate_cython__(CYTHON_UN /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_10UnknownKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_10UnknownKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_10UnknownKey___cinit__(((struct __pyx_obj_3ssh_8keytypes_UnknownKey *)__pyx_v_self)); /* function exit code */ @@ -2149,8 +3809,6 @@ static int __pyx_pw_3ssh_8keytypes_10UnknownKey_1__cinit__(PyObject *__pyx_v_sel static int __pyx_pf_3ssh_8keytypes_10UnknownKey___cinit__(struct __pyx_obj_3ssh_8keytypes_UnknownKey *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":45 * cdef class UnknownKey(KeyType): @@ -2171,23 +3829,50 @@ static int __pyx_pf_3ssh_8keytypes_10UnknownKey___cinit__(struct __pyx_obj_3ssh_ /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10UnknownKey_2__reduce_cython__[] = "UnknownKey.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10UnknownKey_2__reduce_cython__, "UnknownKey.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10UnknownKey_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10UnknownKey_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_10UnknownKey_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_UnknownKey *)__pyx_v_self)); /* function exit code */ @@ -2198,33 +3883,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__(PyObjec static PyObject *__pyx_pf_3ssh_8keytypes_10UnknownKey_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_UnknownKey *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.UnknownKey.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2234,21 +3914,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10UnknownKey_2__reduce_cython__(CYTHON_ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10UnknownKey_4__setstate_cython__[] = "UnknownKey.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10UnknownKey_4__setstate_cython__, "UnknownKey.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10UnknownKey_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10UnknownKey_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_10UnknownKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_UnknownKey *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.UnknownKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_10UnknownKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_UnknownKey *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2256,33 +4019,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__(PyObj static PyObject *__pyx_pf_3ssh_8keytypes_10UnknownKey_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_UnknownKey *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.UnknownKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2301,12 +4059,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10UnknownKey_4__setstate_cython__(CYTHO /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_6DSSKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_6DSSKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_6DSSKey___cinit__(((struct __pyx_obj_3ssh_8keytypes_DSSKey *)__pyx_v_self)); /* function exit code */ @@ -2316,8 +4082,6 @@ static int __pyx_pw_3ssh_8keytypes_6DSSKey_1__cinit__(PyObject *__pyx_v_self, Py static int __pyx_pf_3ssh_8keytypes_6DSSKey___cinit__(struct __pyx_obj_3ssh_8keytypes_DSSKey *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":50 * cdef class DSSKey(KeyType): @@ -2338,23 +4102,50 @@ static int __pyx_pf_3ssh_8keytypes_6DSSKey___cinit__(struct __pyx_obj_3ssh_8keyt /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_6DSSKey_2__reduce_cython__[] = "DSSKey.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_6DSSKey_2__reduce_cython__, "DSSKey.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_6DSSKey_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6DSSKey_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_6DSSKey_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_DSSKey *)__pyx_v_self)); /* function exit code */ @@ -2365,33 +4156,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__(PyObject *__ static PyObject *__pyx_pf_3ssh_8keytypes_6DSSKey_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_DSSKey *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.DSSKey.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2401,21 +4187,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_6DSSKey_2__reduce_cython__(CYTHON_UNUSE /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_6DSSKey_4__setstate_cython__[] = "DSSKey.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_6DSSKey_4__setstate_cython__, "DSSKey.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_6DSSKey_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6DSSKey_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_6DSSKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_DSSKey *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.DSSKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_6DSSKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_DSSKey *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2423,33 +4292,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__(PyObject * static PyObject *__pyx_pf_3ssh_8keytypes_6DSSKey_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_DSSKey *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.DSSKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2468,12 +4332,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_6DSSKey_4__setstate_cython__(CYTHON_UNU /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_6RSAKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_6RSAKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_6RSAKey___cinit__(((struct __pyx_obj_3ssh_8keytypes_RSAKey *)__pyx_v_self)); /* function exit code */ @@ -2483,8 +4355,6 @@ static int __pyx_pw_3ssh_8keytypes_6RSAKey_1__cinit__(PyObject *__pyx_v_self, Py static int __pyx_pf_3ssh_8keytypes_6RSAKey___cinit__(struct __pyx_obj_3ssh_8keytypes_RSAKey *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":55 * cdef class RSAKey(KeyType): @@ -2505,23 +4375,50 @@ static int __pyx_pf_3ssh_8keytypes_6RSAKey___cinit__(struct __pyx_obj_3ssh_8keyt /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_6RSAKey_2__reduce_cython__[] = "RSAKey.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_6RSAKey_2__reduce_cython__, "RSAKey.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_6RSAKey_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6RSAKey_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_6RSAKey_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_RSAKey *)__pyx_v_self)); /* function exit code */ @@ -2532,33 +4429,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__(PyObject *__ static PyObject *__pyx_pf_3ssh_8keytypes_6RSAKey_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_RSAKey *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.RSAKey.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2568,21 +4460,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_6RSAKey_2__reduce_cython__(CYTHON_UNUSE /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_6RSAKey_4__setstate_cython__[] = "RSAKey.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_6RSAKey_4__setstate_cython__, "RSAKey.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_6RSAKey_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6RSAKey_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_6RSAKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_RSAKey *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.RSAKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_6RSAKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_RSAKey *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2590,33 +4565,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__(PyObject * static PyObject *__pyx_pf_3ssh_8keytypes_6RSAKey_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_RSAKey *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.RSAKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2635,12 +4605,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_6RSAKey_4__setstate_cython__(CYTHON_UNU /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_7RSA1Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_7RSA1Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_7RSA1Key___cinit__(((struct __pyx_obj_3ssh_8keytypes_RSA1Key *)__pyx_v_self)); /* function exit code */ @@ -2650,8 +4628,6 @@ static int __pyx_pw_3ssh_8keytypes_7RSA1Key_1__cinit__(PyObject *__pyx_v_self, P static int __pyx_pf_3ssh_8keytypes_7RSA1Key___cinit__(struct __pyx_obj_3ssh_8keytypes_RSA1Key *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":60 * cdef class RSA1Key(KeyType): @@ -2672,23 +4648,50 @@ static int __pyx_pf_3ssh_8keytypes_7RSA1Key___cinit__(struct __pyx_obj_3ssh_8key /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_7RSA1Key_2__reduce_cython__[] = "RSA1Key.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_7RSA1Key_2__reduce_cython__, "RSA1Key.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_7RSA1Key_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7RSA1Key_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_7RSA1Key_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_RSA1Key *)__pyx_v_self)); /* function exit code */ @@ -2699,33 +4702,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__(PyObject *_ static PyObject *__pyx_pf_3ssh_8keytypes_7RSA1Key_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_RSA1Key *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.RSA1Key.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2735,21 +4733,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7RSA1Key_2__reduce_cython__(CYTHON_UNUS /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_7RSA1Key_4__setstate_cython__[] = "RSA1Key.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_7RSA1Key_4__setstate_cython__, "RSA1Key.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_7RSA1Key_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7RSA1Key_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_7RSA1Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_RSA1Key *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.RSA1Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_7RSA1Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_RSA1Key *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2757,33 +4838,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__(PyObject static PyObject *__pyx_pf_3ssh_8keytypes_7RSA1Key_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_RSA1Key *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.RSA1Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2802,12 +4878,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_7RSA1Key_4__setstate_cython__(CYTHON_UN /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_8ECDSAKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_8ECDSAKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_8ECDSAKey___cinit__(((struct __pyx_obj_3ssh_8keytypes_ECDSAKey *)__pyx_v_self)); /* function exit code */ @@ -2817,8 +4901,6 @@ static int __pyx_pw_3ssh_8keytypes_8ECDSAKey_1__cinit__(PyObject *__pyx_v_self, static int __pyx_pf_3ssh_8keytypes_8ECDSAKey___cinit__(struct __pyx_obj_3ssh_8keytypes_ECDSAKey *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":65 * cdef class ECDSAKey(KeyType): @@ -2839,23 +4921,50 @@ static int __pyx_pf_3ssh_8keytypes_8ECDSAKey___cinit__(struct __pyx_obj_3ssh_8ke /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__[] = "ECDSAKey.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__, "ECDSAKey.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSAKey *)__pyx_v_self)); /* function exit code */ @@ -2866,33 +4975,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__(PyObject * static PyObject *__pyx_pf_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSAKey *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSAKey.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2902,21 +5006,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__(CYTHON_UNU /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__[] = "ECDSAKey.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__, "ECDSAKey.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSAKey *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ECDSAKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSAKey *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2924,33 +5111,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__(PyObject static PyObject *__pyx_pf_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSAKey *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSAKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -2969,12 +5151,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__(CYTHON_U /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_12DSSCert01Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_12DSSCert01Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_12DSSCert01Key___cinit__(((struct __pyx_obj_3ssh_8keytypes_DSSCert01Key *)__pyx_v_self)); /* function exit code */ @@ -2984,8 +5174,6 @@ static int __pyx_pw_3ssh_8keytypes_12DSSCert01Key_1__cinit__(PyObject *__pyx_v_s static int __pyx_pf_3ssh_8keytypes_12DSSCert01Key___cinit__(struct __pyx_obj_3ssh_8keytypes_DSSCert01Key *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":70 * cdef class DSSCert01Key(KeyType): @@ -3006,23 +5194,50 @@ static int __pyx_pf_3ssh_8keytypes_12DSSCert01Key___cinit__(struct __pyx_obj_3ss /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__[] = "DSSCert01Key.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__, "DSSCert01Key.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_DSSCert01Key *)__pyx_v_self)); /* function exit code */ @@ -3033,33 +5248,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__(PyObj static PyObject *__pyx_pf_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_DSSCert01Key *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.DSSCert01Key.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3069,21 +5279,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__(CYTHO /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__[] = "DSSCert01Key.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__, "DSSCert01Key.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_DSSCert01Key *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.DSSCert01Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_DSSCert01Key *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3091,33 +5384,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__(PyO static PyObject *__pyx_pf_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_DSSCert01Key *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.DSSCert01Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3136,12 +5424,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__(CYT /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_12RSACert01Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_12RSACert01Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_12RSACert01Key___cinit__(((struct __pyx_obj_3ssh_8keytypes_RSACert01Key *)__pyx_v_self)); /* function exit code */ @@ -3151,8 +5447,6 @@ static int __pyx_pw_3ssh_8keytypes_12RSACert01Key_1__cinit__(PyObject *__pyx_v_s static int __pyx_pf_3ssh_8keytypes_12RSACert01Key___cinit__(struct __pyx_obj_3ssh_8keytypes_RSACert01Key *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":75 * cdef class RSACert01Key(KeyType): @@ -3173,23 +5467,50 @@ static int __pyx_pf_3ssh_8keytypes_12RSACert01Key___cinit__(struct __pyx_obj_3ss /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__[] = "RSACert01Key.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__, "RSACert01Key.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_RSACert01Key *)__pyx_v_self)); /* function exit code */ @@ -3200,33 +5521,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__(PyObj static PyObject *__pyx_pf_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_RSACert01Key *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.RSACert01Key.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3236,21 +5552,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__(CYTHO /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__[] = "RSACert01Key.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__, "RSACert01Key.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_RSACert01Key *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.RSACert01Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_RSACert01Key *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3258,33 +5657,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__(PyO static PyObject *__pyx_pf_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_RSACert01Key *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.RSACert01Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3303,12 +5697,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__(CYT /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P256_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P256_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P256___cinit__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256 *)__pyx_v_self)); /* function exit code */ @@ -3318,8 +5720,6 @@ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P256_1__cinit__(PyObject *__pyx_v_sel static int __pyx_pf_3ssh_8keytypes_10ECDSA_P256___cinit__(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256 *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":80 * cdef class ECDSA_P256(KeyType): @@ -3340,23 +5740,50 @@ static int __pyx_pf_3ssh_8keytypes_10ECDSA_P256___cinit__(struct __pyx_obj_3ssh_ /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__[] = "ECDSA_P256.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__, "ECDSA_P256.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256 *)__pyx_v_self)); /* function exit code */ @@ -3367,33 +5794,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__(PyObjec static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P256 *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P256.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3403,21 +5825,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__(CYTHON_ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__[] = "ECDSA_P256.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__, "ECDSA_P256.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256 *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ECDSA_P256.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256 *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3425,33 +5930,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__(PyObj static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P256 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P256.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3470,12 +5970,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__(CYTHO /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P384_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P384_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P384___cinit__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384 *)__pyx_v_self)); /* function exit code */ @@ -3485,8 +5993,6 @@ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P384_1__cinit__(PyObject *__pyx_v_sel static int __pyx_pf_3ssh_8keytypes_10ECDSA_P384___cinit__(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384 *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":85 * cdef class ECDSA_P384(KeyType): @@ -3507,23 +6013,50 @@ static int __pyx_pf_3ssh_8keytypes_10ECDSA_P384___cinit__(struct __pyx_obj_3ssh_ /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__[] = "ECDSA_P384.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__, "ECDSA_P384.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384 *)__pyx_v_self)); /* function exit code */ @@ -3534,33 +6067,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__(PyObjec static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P384 *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P384.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3570,21 +6098,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__(CYTHON_ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__[] = "ECDSA_P384.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__, "ECDSA_P384.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384 *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ECDSA_P384.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384 *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3592,33 +6203,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__(PyObj static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P384 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P384.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3637,12 +6243,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__(CYTHO /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P521_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P521_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P521___cinit__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521 *)__pyx_v_self)); /* function exit code */ @@ -3652,8 +6266,6 @@ static int __pyx_pw_3ssh_8keytypes_10ECDSA_P521_1__cinit__(PyObject *__pyx_v_sel static int __pyx_pf_3ssh_8keytypes_10ECDSA_P521___cinit__(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521 *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":90 * cdef class ECDSA_P521(KeyType): @@ -3674,23 +6286,50 @@ static int __pyx_pf_3ssh_8keytypes_10ECDSA_P521___cinit__(struct __pyx_obj_3ssh_ /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__[] = "ECDSA_P521.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__, "ECDSA_P521.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521 *)__pyx_v_self)); /* function exit code */ @@ -3701,33 +6340,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__(PyObjec static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P521 *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P521.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3737,21 +6371,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__(CYTHON_ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__[] = "ECDSA_P521.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__, "ECDSA_P521.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521 *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ECDSA_P521.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521 *)__pyx_v_self), __pyx_v___pyx_state); + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3759,33 +6476,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__(PyObj static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P521 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P521.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3804,12 +6516,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__(CYTHO /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01___cinit__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -3819,8 +6539,6 @@ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_1__cinit__(PyObject *__py static int __pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01___cinit__(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01 *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":95 * cdef class ECDSA_P256_CERT01(KeyType): @@ -3841,23 +6559,50 @@ static int __pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01___cinit__(struct __pyx_ob /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__[] = "ECDSA_P256_CERT01.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__, "ECDSA_P256_CERT01.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -3868,33 +6613,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__( static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01 *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P256_CERT01.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3904,21 +6644,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__( /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__[] = "ECDSA_P256_CERT01.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__, "ECDSA_P256_CERT01.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01 *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ECDSA_P256_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01 *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3926,33 +6749,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython_ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P256_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3971,12 +6789,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython_ /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01___cinit__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -3986,8 +6812,6 @@ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_1__cinit__(PyObject *__py static int __pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01___cinit__(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01 *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":100 * cdef class ECDSA_P384_CERT01(KeyType): @@ -4008,23 +6832,50 @@ static int __pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01___cinit__(struct __pyx_ob /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__[] = "ECDSA_P384_CERT01.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__, "ECDSA_P384_CERT01.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -4035,33 +6886,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__( static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01 *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P384_CERT01.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4071,21 +6917,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__( /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__[] = "ECDSA_P384_CERT01.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__, "ECDSA_P384_CERT01.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01 *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ECDSA_P384_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01 *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4093,33 +7022,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython_ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P384_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4138,12 +7062,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython_ /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01___cinit__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -4153,8 +7085,6 @@ static int __pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_1__cinit__(PyObject *__py static int __pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01___cinit__(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01 *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":105 * cdef class ECDSA_P521_CERT01(KeyType): @@ -4175,23 +7105,50 @@ static int __pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01___cinit__(struct __pyx_ob /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__[] = "ECDSA_P521_CERT01.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__, "ECDSA_P521_CERT01.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -4202,33 +7159,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__( static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01 *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P521_CERT01.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4238,21 +7190,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__( /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__[] = "ECDSA_P521_CERT01.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__, "ECDSA_P521_CERT01.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01 *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ECDSA_P521_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01 *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4260,33 +7295,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython_ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ECDSA_P521_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4305,12 +7335,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython_ /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_10ED25519Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_10ED25519Key_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_10ED25519Key___cinit__(((struct __pyx_obj_3ssh_8keytypes_ED25519Key *)__pyx_v_self)); /* function exit code */ @@ -4320,8 +7358,6 @@ static int __pyx_pw_3ssh_8keytypes_10ED25519Key_1__cinit__(PyObject *__pyx_v_sel static int __pyx_pf_3ssh_8keytypes_10ED25519Key___cinit__(struct __pyx_obj_3ssh_8keytypes_ED25519Key *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":110 * cdef class ED25519Key(KeyType): @@ -4342,23 +7378,50 @@ static int __pyx_pf_3ssh_8keytypes_10ED25519Key___cinit__(struct __pyx_obj_3ssh_ /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ED25519Key_2__reduce_cython__[] = "ED25519Key.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ED25519Key_2__reduce_cython__, "ED25519Key.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ED25519Key_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ED25519Key_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_10ED25519Key_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ED25519Key *)__pyx_v_self)); /* function exit code */ @@ -4369,33 +7432,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__(PyObjec static PyObject *__pyx_pf_3ssh_8keytypes_10ED25519Key_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ED25519Key *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ED25519Key.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4405,21 +7463,104 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ED25519Key_2__reduce_cython__(CYTHON_ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_10ED25519Key_4__setstate_cython__[] = "ED25519Key.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_10ED25519Key_4__setstate_cython__, "ED25519Key.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_10ED25519Key_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ED25519Key_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_10ED25519Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ED25519Key *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ED25519Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_10ED25519Key_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ED25519Key *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4427,33 +7568,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__(PyObj static PyObject *__pyx_pf_3ssh_8keytypes_10ED25519Key_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ED25519Key *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { 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("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ED25519Key.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4472,12 +7608,20 @@ static PyObject *__pyx_pf_3ssh_8keytypes_10ED25519Key_4__setstate_cython__(CYTHO /* Python wrapper */ static int __pyx_pw_3ssh_8keytypes_14ED25519_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_3ssh_8keytypes_14ED25519_CERT01_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { - __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} - if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_3ssh_8keytypes_14ED25519_CERT01___cinit__(((struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -4487,8 +7631,6 @@ static int __pyx_pw_3ssh_8keytypes_14ED25519_CERT01_1__cinit__(PyObject *__pyx_v static int __pyx_pf_3ssh_8keytypes_14ED25519_CERT01___cinit__(struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *__pyx_v_self) { int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__", 0); /* "ssh/keytypes.pyx":115 * cdef class ED25519_CERT01(KeyType): @@ -4509,23 +7651,50 @@ static int __pyx_pf_3ssh_8keytypes_14ED25519_CERT01___cinit__(struct __pyx_obj_3 /* function exit code */ __pyx_r = 0; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__[] = "ED25519_CERT01.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__, "ED25519_CERT01.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__(((struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *)__pyx_v_self)); /* function exit code */ @@ -4536,33 +7705,28 @@ static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__(PyO static PyObject *__pyx_pf_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *__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("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ED25519_CERT01.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4572,55 +7736,133 @@ static PyObject *__pyx_pf_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__(CYT /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__[] = "ED25519_CERT01.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; +static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__, "ED25519_CERT01.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_5__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; - __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_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.ED25519_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__(((struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01 *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("ssh.keytypes.ED25519_CERT01.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4644,7 +7886,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("from_keytype", 0); + __Pyx_RefNannySetupContext("from_keytype", 1); /* "ssh/keytypes.pyx":119 * @@ -4663,7 +7905,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_DSS: * return DSSKey() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_UnknownKey)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4687,7 +7929,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_RSA: * return RSAKey() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_DSSKey)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4711,7 +7953,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_RSA1: * return RSA1Key() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_RSAKey)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4735,7 +7977,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ECDSA: * return ECDSAKey() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_RSA1Key)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4759,7 +8001,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_DSS_CERT01: * return DSSCert01Key() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ECDSAKey)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4783,7 +8025,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_RSA_CERT01: * return RSACert01Key() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_DSSCert01Key)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 130, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4807,7 +8049,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ECDSA_P256: * return ECDSA_P256() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_RSACert01Key)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 132, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4831,7 +8073,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ECDSA_P384: * return ECDSA_P384() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ECDSA_P256)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4855,7 +8097,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ECDSA_P521: * return ECDSA_P521() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ECDSA_P384)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4879,7 +8121,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ECDSA_P256_CERT01: * return ECDSA_P256_CERT01() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ECDSA_P521)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4903,7 +8145,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ECDSA_P384_CERT01: * return ECDSA_P384_CERT01() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4927,7 +8169,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ECDSA_P521_CERT01: * return ECDSA_P521_CERT01() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4951,7 +8193,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ED25519: * return ED25519Key() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4975,7 +8217,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * elif _type == ssh_keytypes_e.SSH_KEYTYPE_ED25519_CERT01: * return ED25519_CERT01() */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ED25519Key)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 146, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -4999,7 +8241,7 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt * else: * raise ValueError("Unknown keytype %s", _type) */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_3ssh_8keytypes_ED25519_CERT01)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_3ssh_8keytypes_KeyType *)__pyx_t_1); @@ -5029,9 +8271,9 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_kp_s_Unknown_keytype_s); __Pyx_GIVEREF(__pyx_kp_s_Unknown_keytype_s); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_s_Unknown_keytype_s); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_s_Unknown_keytype_s)) __PYX_ERR(1, 150, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(1, 150, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 150, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5071,16 +8313,98 @@ static struct __pyx_obj_3ssh_8keytypes_KeyType *__pyx_f_3ssh_8keytypes_from_keyt */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_8keytypes_1key_type_from_name(PyObject *__pyx_self, PyObject *__pyx_v_key_name); /*proto*/ -static char __pyx_doc_3ssh_8keytypes_key_type_from_name[] = "key_type_from_name(key_name)"; -static PyMethodDef __pyx_mdef_3ssh_8keytypes_1key_type_from_name = {"key_type_from_name", (PyCFunction)__pyx_pw_3ssh_8keytypes_1key_type_from_name, METH_O, __pyx_doc_3ssh_8keytypes_key_type_from_name}; -static PyObject *__pyx_pw_3ssh_8keytypes_1key_type_from_name(PyObject *__pyx_self, PyObject *__pyx_v_key_name) { +static PyObject *__pyx_pw_3ssh_8keytypes_1key_type_from_name(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_8keytypes_key_type_from_name, "key_type_from_name(key_name)"); +static PyMethodDef __pyx_mdef_3ssh_8keytypes_1key_type_from_name = {"key_type_from_name", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_1key_type_from_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_key_type_from_name}; +static PyObject *__pyx_pw_3ssh_8keytypes_1key_type_from_name(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_key_name = 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("key_type_from_name (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_8keytypes_key_type_from_name(__pyx_self, ((PyObject *)__pyx_v_key_name)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_key_name,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 153, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "key_type_from_name") < 0)) __PYX_ERR(1, 153, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_key_name = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("key_type_from_name", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 153, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.keytypes.key_type_from_name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_8keytypes_key_type_from_name(__pyx_self, __pyx_v_key_name); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5096,7 +8420,7 @@ static PyObject *__pyx_pf_3ssh_8keytypes_key_type_from_name(CYTHON_UNUSED PyObje int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("key_type_from_name", 0); + __Pyx_RefNannySetupContext("key_type_from_name", 1); /* "ssh/keytypes.pyx":155 * def key_type_from_name(key_name): @@ -5134,6 +8458,7 @@ static PyObject *__pyx_pf_3ssh_8keytypes_key_type_from_name(CYTHON_UNUSED PyObje { #ifdef WITH_THREAD PyThreadState *_save; + _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif @@ -5201,12 +8526,17 @@ static PyObject *__pyx_pf_3ssh_8keytypes_key_type_from_name(CYTHON_UNUSED PyObje static PyObject *__pyx_tp_new_3ssh_8keytypes_KeyType(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif if (unlikely(__pyx_pw_3ssh_8keytypes_7KeyType_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; return o; bad: @@ -5216,20 +8546,34 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_KeyType(PyTypeObject *t, CYTHON_UNU static void __pyx_tp_dealloc_3ssh_8keytypes_KeyType(PyObject *o) { #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { - if (PyObject_CallFinalizerFromDealloc(o)) return; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_3ssh_8keytypes_KeyType) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyObject *__pyx_getprop_3ssh_8keytypes_7KeyType_value(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_3ssh_8keytypes_7KeyType_5value_1__get__(o); } +static PyObject *__pyx_specialmethod___pyx_pw_3ssh_8keytypes_7KeyType_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__(self); +} + static PyMethodDef __pyx_methods_3ssh_8keytypes_KeyType[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_7KeyType_6__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_7KeyType_8__setstate_cython__}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7KeyType_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7KeyType_6__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7KeyType_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7KeyType_8__setstate_cython__}, {0, 0, 0, 0} }; @@ -5237,10 +8581,28 @@ static struct PyGetSetDef __pyx_getsets_3ssh_8keytypes_KeyType[] = { {(char *)"value", __pyx_getprop_3ssh_8keytypes_7KeyType_value, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_KeyType_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_3ssh_8keytypes_KeyType}, + {Py_tp_repr, (void *)__pyx_pw_3ssh_8keytypes_7KeyType_5__repr__}, + {Py_tp_str, (void *)__pyx_pw_3ssh_8keytypes_7KeyType_3__str__}, + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_KeyType}, + {Py_tp_getset, (void *)__pyx_getsets_3ssh_8keytypes_KeyType}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_KeyType}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_KeyType_spec = { + "ssh.keytypes.KeyType", + sizeof(struct __pyx_obj_3ssh_8keytypes_KeyType), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_KeyType_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_KeyType = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.KeyType", /*tp_name*/ + "ssh.keytypes.""KeyType", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_KeyType), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5283,7 +8645,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_KeyType = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_KeyType, /*tp_new*/ @@ -5297,18 +8661,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_KeyType = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_DSSKey(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5321,14 +8693,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_DSSKey(PyTypeObject *t, PyObject *a } static PyMethodDef __pyx_methods_3ssh_8keytypes_DSSKey[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_6DSSKey_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_6DSSKey_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6DSSKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6DSSKey_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6DSSKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6DSSKey_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_DSSKey_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_DSSKey}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_DSSKey}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_DSSKey_spec = { + "ssh.keytypes.DSSKey", + sizeof(struct __pyx_obj_3ssh_8keytypes_DSSKey), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_DSSKey_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_DSSKey = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.DSSKey", /*tp_name*/ + "ssh.keytypes.""DSSKey", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_DSSKey), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5346,7 +8732,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSKey = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -5356,7 +8742,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSKey = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -5379,7 +8765,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSKey = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_DSSKey, /*tp_new*/ @@ -5393,18 +8781,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSKey = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_RSAKey(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5417,14 +8813,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_RSAKey(PyTypeObject *t, PyObject *a } static PyMethodDef __pyx_methods_3ssh_8keytypes_RSAKey[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_6RSAKey_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_6RSAKey_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6RSAKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6RSAKey_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_6RSAKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_6RSAKey_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_RSAKey_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_RSAKey}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_RSAKey}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_RSAKey_spec = { + "ssh.keytypes.RSAKey", + sizeof(struct __pyx_obj_3ssh_8keytypes_RSAKey), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_RSAKey_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_RSAKey = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.RSAKey", /*tp_name*/ + "ssh.keytypes.""RSAKey", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_RSAKey), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5442,7 +8852,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSAKey = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -5452,7 +8862,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSAKey = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -5475,7 +8885,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSAKey = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_RSAKey, /*tp_new*/ @@ -5489,18 +8901,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSAKey = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_RSA1Key(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5513,14 +8933,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_RSA1Key(PyTypeObject *t, PyObject * } static PyMethodDef __pyx_methods_3ssh_8keytypes_RSA1Key[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_7RSA1Key_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_7RSA1Key_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7RSA1Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7RSA1Key_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_7RSA1Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_7RSA1Key_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_RSA1Key_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_RSA1Key}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_RSA1Key}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_RSA1Key_spec = { + "ssh.keytypes.RSA1Key", + sizeof(struct __pyx_obj_3ssh_8keytypes_RSA1Key), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_RSA1Key_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_RSA1Key = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.RSA1Key", /*tp_name*/ + "ssh.keytypes.""RSA1Key", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_RSA1Key), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5538,7 +8972,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSA1Key = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -5548,7 +8982,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSA1Key = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -5571,7 +9005,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSA1Key = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_RSA1Key, /*tp_new*/ @@ -5585,18 +9021,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSA1Key = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSAKey(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5609,14 +9053,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSAKey(PyTypeObject *t, PyObject } static PyMethodDef __pyx_methods_3ssh_8keytypes_ECDSAKey[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_8ECDSAKey_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_8ECDSAKey_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ECDSAKey_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ECDSAKey}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ECDSAKey}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ECDSAKey_spec = { + "ssh.keytypes.ECDSAKey", + sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSAKey), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ECDSAKey_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSAKey = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ECDSAKey", /*tp_name*/ + "ssh.keytypes.""ECDSAKey", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSAKey), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5634,7 +9092,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSAKey = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -5644,7 +9102,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSAKey = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -5667,7 +9125,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSAKey = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ECDSAKey, /*tp_new*/ @@ -5681,18 +9141,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSAKey = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_DSSCert01Key(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5705,14 +9173,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_DSSCert01Key(PyTypeObject *t, PyObj } static PyMethodDef __pyx_methods_3ssh_8keytypes_DSSCert01Key[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12DSSCert01Key_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12DSSCert01Key_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_DSSCert01Key_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_DSSCert01Key}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_DSSCert01Key}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_DSSCert01Key_spec = { + "ssh.keytypes.DSSCert01Key", + sizeof(struct __pyx_obj_3ssh_8keytypes_DSSCert01Key), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_DSSCert01Key_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_DSSCert01Key = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.DSSCert01Key", /*tp_name*/ + "ssh.keytypes.""DSSCert01Key", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_DSSCert01Key), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5730,7 +9212,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSCert01Key = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -5740,7 +9222,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSCert01Key = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -5763,7 +9245,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSCert01Key = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_DSSCert01Key, /*tp_new*/ @@ -5777,18 +9261,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_DSSCert01Key = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_RSACert01Key(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5801,14 +9293,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_RSACert01Key(PyTypeObject *t, PyObj } static PyMethodDef __pyx_methods_3ssh_8keytypes_RSACert01Key[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12RSACert01Key_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_12RSACert01Key_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_RSACert01Key_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_RSACert01Key}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_RSACert01Key}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_RSACert01Key_spec = { + "ssh.keytypes.RSACert01Key", + sizeof(struct __pyx_obj_3ssh_8keytypes_RSACert01Key), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_RSACert01Key_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_RSACert01Key = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.RSACert01Key", /*tp_name*/ + "ssh.keytypes.""RSACert01Key", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_RSACert01Key), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5826,7 +9332,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSACert01Key = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -5836,7 +9342,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSACert01Key = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -5859,7 +9365,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSACert01Key = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_RSACert01Key, /*tp_new*/ @@ -5873,18 +9381,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_RSACert01Key = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P256(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5897,14 +9413,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P256(PyTypeObject *t, PyObjec } static PyMethodDef __pyx_methods_3ssh_8keytypes_ECDSA_P256[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P256_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P256_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ECDSA_P256_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ECDSA_P256}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ECDSA_P256}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ECDSA_P256_spec = { + "ssh.keytypes.ECDSA_P256", + sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ECDSA_P256_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256 = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ECDSA_P256", /*tp_name*/ + "ssh.keytypes.""ECDSA_P256", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -5922,7 +9452,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256 = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -5932,7 +9462,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256 = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -5955,7 +9485,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256 = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ECDSA_P256, /*tp_new*/ @@ -5969,18 +9501,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256 = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P384(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -5993,14 +9533,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P384(PyTypeObject *t, PyObjec } static PyMethodDef __pyx_methods_3ssh_8keytypes_ECDSA_P384[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P384_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P384_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ECDSA_P384_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ECDSA_P384}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ECDSA_P384}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ECDSA_P384_spec = { + "ssh.keytypes.ECDSA_P384", + sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ECDSA_P384_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384 = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ECDSA_P384", /*tp_name*/ + "ssh.keytypes.""ECDSA_P384", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6018,7 +9572,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384 = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6028,7 +9582,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384 = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6051,7 +9605,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384 = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ECDSA_P384, /*tp_new*/ @@ -6065,18 +9621,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384 = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P521(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -6089,14 +9653,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P521(PyTypeObject *t, PyObjec } static PyMethodDef __pyx_methods_3ssh_8keytypes_ECDSA_P521[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P521_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ECDSA_P521_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ECDSA_P521_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ECDSA_P521}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ECDSA_P521}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ECDSA_P521_spec = { + "ssh.keytypes.ECDSA_P521", + sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ECDSA_P521_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521 = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ECDSA_P521", /*tp_name*/ + "ssh.keytypes.""ECDSA_P521", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6114,7 +9692,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521 = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6124,7 +9702,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521 = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6147,7 +9725,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521 = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ECDSA_P521, /*tp_new*/ @@ -6161,18 +9741,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521 = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P256_CERT01(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -6185,14 +9773,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P256_CERT01(PyTypeObject *t, } static PyMethodDef __pyx_methods_3ssh_8keytypes_ECDSA_P256_CERT01[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P256_CERT01_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ECDSA_P256_CERT01}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ECDSA_P256_CERT01}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01_spec = { + "ssh.keytypes.ECDSA_P256_CERT01", + sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01 = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ECDSA_P256_CERT01", /*tp_name*/ + "ssh.keytypes.""ECDSA_P256_CERT01", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P256_CERT01), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6210,7 +9812,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01 = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6220,7 +9822,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01 = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6243,7 +9845,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01 = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ECDSA_P256_CERT01, /*tp_new*/ @@ -6257,18 +9861,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01 = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P384_CERT01(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -6281,14 +9893,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P384_CERT01(PyTypeObject *t, } static PyMethodDef __pyx_methods_3ssh_8keytypes_ECDSA_P384_CERT01[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P384_CERT01_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ECDSA_P384_CERT01}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ECDSA_P384_CERT01}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01_spec = { + "ssh.keytypes.ECDSA_P384_CERT01", + sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01 = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ECDSA_P384_CERT01", /*tp_name*/ + "ssh.keytypes.""ECDSA_P384_CERT01", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P384_CERT01), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6306,7 +9932,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01 = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6316,7 +9942,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01 = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6339,7 +9965,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01 = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ECDSA_P384_CERT01, /*tp_new*/ @@ -6353,18 +9981,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01 = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P521_CERT01(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -6377,14 +10013,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ECDSA_P521_CERT01(PyTypeObject *t, } static PyMethodDef __pyx_methods_3ssh_8keytypes_ECDSA_P521_CERT01[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_17ECDSA_P521_CERT01_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ECDSA_P521_CERT01}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ECDSA_P521_CERT01}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01_spec = { + "ssh.keytypes.ECDSA_P521_CERT01", + sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01 = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ECDSA_P521_CERT01", /*tp_name*/ + "ssh.keytypes.""ECDSA_P521_CERT01", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ECDSA_P521_CERT01), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6402,7 +10052,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01 = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6412,7 +10062,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01 = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6435,7 +10085,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01 = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ECDSA_P521_CERT01, /*tp_new*/ @@ -6449,18 +10101,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01 = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ED25519_CERT01(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -6473,14 +10133,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ED25519_CERT01(PyTypeObject *t, PyO } static PyMethodDef __pyx_methods_3ssh_8keytypes_ED25519_CERT01[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_14ED25519_CERT01_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ED25519_CERT01_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ED25519_CERT01}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ED25519_CERT01}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ED25519_CERT01_spec = { + "ssh.keytypes.ED25519_CERT01", + sizeof(struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ED25519_CERT01_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519_CERT01 = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ED25519_CERT01", /*tp_name*/ + "ssh.keytypes.""ED25519_CERT01", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ED25519_CERT01), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6498,7 +10172,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519_CERT01 = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6508,7 +10182,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519_CERT01 = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6531,7 +10205,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519_CERT01 = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ED25519_CERT01, /*tp_new*/ @@ -6545,18 +10221,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519_CERT01 = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_UnknownKey(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -6569,14 +10253,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_UnknownKey(PyTypeObject *t, PyObjec } static PyMethodDef __pyx_methods_3ssh_8keytypes_UnknownKey[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_10UnknownKey_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_10UnknownKey_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10UnknownKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10UnknownKey_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10UnknownKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10UnknownKey_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_UnknownKey_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_UnknownKey}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_UnknownKey}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_UnknownKey_spec = { + "ssh.keytypes.UnknownKey", + sizeof(struct __pyx_obj_3ssh_8keytypes_UnknownKey), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_UnknownKey_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_UnknownKey = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.UnknownKey", /*tp_name*/ + "ssh.keytypes.""UnknownKey", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_UnknownKey), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6594,7 +10292,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_UnknownKey = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6604,7 +10302,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_UnknownKey = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6627,7 +10325,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_UnknownKey = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_UnknownKey, /*tp_new*/ @@ -6641,18 +10341,26 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_UnknownKey = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_3ssh_8keytypes_ED25519Key(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = __pyx_tp_new_3ssh_8keytypes_KeyType(t, a, k); @@ -6665,14 +10373,28 @@ static PyObject *__pyx_tp_new_3ssh_8keytypes_ED25519Key(PyTypeObject *t, PyObjec } static PyMethodDef __pyx_methods_3ssh_8keytypes_ED25519Key[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__, METH_NOARGS, __pyx_doc_3ssh_8keytypes_10ED25519Key_2__reduce_cython__}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__, METH_O, __pyx_doc_3ssh_8keytypes_10ED25519Key_4__setstate_cython__}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ED25519Key_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ED25519Key_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_8keytypes_10ED25519Key_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_8keytypes_10ED25519Key_4__setstate_cython__}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_3ssh_8keytypes_ED25519Key_slots[] = { + {Py_tp_methods, (void *)__pyx_methods_3ssh_8keytypes_ED25519Key}, + {Py_tp_new, (void *)__pyx_tp_new_3ssh_8keytypes_ED25519Key}, + {0, 0}, +}; +static PyType_Spec __pyx_type_3ssh_8keytypes_ED25519Key_spec = { + "ssh.keytypes.ED25519Key", + sizeof(struct __pyx_obj_3ssh_8keytypes_ED25519Key), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_3ssh_8keytypes_ED25519Key_slots, +}; +#else static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519Key = { PyVarObject_HEAD_INIT(0, 0) - "ssh.keytypes.ED25519Key", /*tp_name*/ + "ssh.keytypes.""ED25519Key", /*tp_name*/ sizeof(struct __pyx_obj_3ssh_8keytypes_ED25519Key), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_3ssh_8keytypes_KeyType, /*tp_dealloc*/ @@ -6690,7 +10412,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519Key = { #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_5__repr__, /*tp_repr*/ #else 0, /*tp_repr*/ @@ -6700,7 +10422,7 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519Key = { 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY + #if CYTHON_COMPILING_IN_PYPY || 0 __pyx_pw_3ssh_8keytypes_7KeyType_3__str__, /*tp_str*/ #else 0, /*tp_str*/ @@ -6723,7 +10445,9 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519Key = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_3ssh_8keytypes_ED25519Key, /*tp_new*/ @@ -6737,54 +10461,30 @@ static PyTypeObject __pyx_type_3ssh_8keytypes_ED25519Key = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_keytypes(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_keytypes}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "keytypes", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE @@ -6794,49 +10494,96 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_DSSCert01Key, __pyx_k_DSSCert01Key, sizeof(__pyx_k_DSSCert01Key), 0, 0, 1, 1}, - {&__pyx_n_s_DSSKey, __pyx_k_DSSKey, sizeof(__pyx_k_DSSKey), 0, 0, 1, 1}, - {&__pyx_n_s_ECDSAKey, __pyx_k_ECDSAKey, sizeof(__pyx_k_ECDSAKey), 0, 0, 1, 1}, - {&__pyx_n_s_ECDSA_P256, __pyx_k_ECDSA_P256, sizeof(__pyx_k_ECDSA_P256), 0, 0, 1, 1}, - {&__pyx_n_s_ECDSA_P256_CERT01, __pyx_k_ECDSA_P256_CERT01, sizeof(__pyx_k_ECDSA_P256_CERT01), 0, 0, 1, 1}, - {&__pyx_n_s_ECDSA_P384, __pyx_k_ECDSA_P384, sizeof(__pyx_k_ECDSA_P384), 0, 0, 1, 1}, - {&__pyx_n_s_ECDSA_P384_CERT01, __pyx_k_ECDSA_P384_CERT01, sizeof(__pyx_k_ECDSA_P384_CERT01), 0, 0, 1, 1}, - {&__pyx_n_s_ECDSA_P521, __pyx_k_ECDSA_P521, sizeof(__pyx_k_ECDSA_P521), 0, 0, 1, 1}, - {&__pyx_n_s_ECDSA_P521_CERT01, __pyx_k_ECDSA_P521_CERT01, sizeof(__pyx_k_ECDSA_P521_CERT01), 0, 0, 1, 1}, - {&__pyx_n_s_ED25519Key, __pyx_k_ED25519Key, sizeof(__pyx_k_ED25519Key), 0, 0, 1, 1}, - {&__pyx_n_s_ED25519_CERT01, __pyx_k_ED25519_CERT01, sizeof(__pyx_k_ED25519_CERT01), 0, 0, 1, 1}, - {&__pyx_n_s_KeyType, __pyx_k_KeyType, sizeof(__pyx_k_KeyType), 0, 0, 1, 1}, - {&__pyx_n_s_RSA1Key, __pyx_k_RSA1Key, sizeof(__pyx_k_RSA1Key), 0, 0, 1, 1}, - {&__pyx_n_s_RSACert01Key, __pyx_k_RSACert01Key, sizeof(__pyx_k_RSACert01Key), 0, 0, 1, 1}, - {&__pyx_n_s_RSAKey, __pyx_k_RSAKey, sizeof(__pyx_k_RSAKey), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_UnknownKey, __pyx_k_UnknownKey, sizeof(__pyx_k_UnknownKey), 0, 0, 1, 1}, - {&__pyx_kp_s_Unknown_keytype_s, __pyx_k_Unknown_keytype_s, sizeof(__pyx_k_Unknown_keytype_s), 0, 0, 1, 0}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_b_key_name, __pyx_k_b_key_name, sizeof(__pyx_k_b_key_name), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_key_name, __pyx_k_key_name, sizeof(__pyx_k_key_name), 0, 0, 1, 1}, - {&__pyx_n_s_key_name_2, __pyx_k_key_name_2, sizeof(__pyx_k_key_name_2), 0, 0, 1, 1}, - {&__pyx_n_s_key_type_from_name, __pyx_k_key_type_from_name, sizeof(__pyx_k_key_type_from_name), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_ssh_keytypes, __pyx_k_ssh_keytypes, sizeof(__pyx_k_ssh_keytypes), 0, 0, 1, 1}, - {&__pyx_kp_s_ssh_keytypes_pyx, __pyx_k_ssh_keytypes_pyx, sizeof(__pyx_k_ssh_keytypes_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_str, __pyx_k_str, sizeof(__pyx_k_str), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, - {&__pyx_n_s_unknown, __pyx_k_unknown, sizeof(__pyx_k_unknown), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_DSSCert01Key, __pyx_k_DSSCert01Key, sizeof(__pyx_k_DSSCert01Key), 0, 0, 1, 1}, + {&__pyx_n_s_DSSCert01Key___reduce_cython, __pyx_k_DSSCert01Key___reduce_cython, sizeof(__pyx_k_DSSCert01Key___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_DSSCert01Key___setstate_cython, __pyx_k_DSSCert01Key___setstate_cython, sizeof(__pyx_k_DSSCert01Key___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_DSSKey, __pyx_k_DSSKey, sizeof(__pyx_k_DSSKey), 0, 0, 1, 1}, + {&__pyx_n_s_DSSKey___reduce_cython, __pyx_k_DSSKey___reduce_cython, sizeof(__pyx_k_DSSKey___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_DSSKey___setstate_cython, __pyx_k_DSSKey___setstate_cython, sizeof(__pyx_k_DSSKey___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSAKey, __pyx_k_ECDSAKey, sizeof(__pyx_k_ECDSAKey), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSAKey___reduce_cython, __pyx_k_ECDSAKey___reduce_cython, sizeof(__pyx_k_ECDSAKey___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSAKey___setstate_cython, __pyx_k_ECDSAKey___setstate_cython, sizeof(__pyx_k_ECDSAKey___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P256, __pyx_k_ECDSA_P256, sizeof(__pyx_k_ECDSA_P256), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P256_CERT01, __pyx_k_ECDSA_P256_CERT01, sizeof(__pyx_k_ECDSA_P256_CERT01), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P256_CERT01___reduce_cytho, __pyx_k_ECDSA_P256_CERT01___reduce_cytho, sizeof(__pyx_k_ECDSA_P256_CERT01___reduce_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P256_CERT01___setstate_cyt, __pyx_k_ECDSA_P256_CERT01___setstate_cyt, sizeof(__pyx_k_ECDSA_P256_CERT01___setstate_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P256___reduce_cython, __pyx_k_ECDSA_P256___reduce_cython, sizeof(__pyx_k_ECDSA_P256___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P256___setstate_cython, __pyx_k_ECDSA_P256___setstate_cython, sizeof(__pyx_k_ECDSA_P256___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P384, __pyx_k_ECDSA_P384, sizeof(__pyx_k_ECDSA_P384), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P384_CERT01, __pyx_k_ECDSA_P384_CERT01, sizeof(__pyx_k_ECDSA_P384_CERT01), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P384_CERT01___reduce_cytho, __pyx_k_ECDSA_P384_CERT01___reduce_cytho, sizeof(__pyx_k_ECDSA_P384_CERT01___reduce_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P384_CERT01___setstate_cyt, __pyx_k_ECDSA_P384_CERT01___setstate_cyt, sizeof(__pyx_k_ECDSA_P384_CERT01___setstate_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P384___reduce_cython, __pyx_k_ECDSA_P384___reduce_cython, sizeof(__pyx_k_ECDSA_P384___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P384___setstate_cython, __pyx_k_ECDSA_P384___setstate_cython, sizeof(__pyx_k_ECDSA_P384___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P521, __pyx_k_ECDSA_P521, sizeof(__pyx_k_ECDSA_P521), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P521_CERT01, __pyx_k_ECDSA_P521_CERT01, sizeof(__pyx_k_ECDSA_P521_CERT01), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P521_CERT01___reduce_cytho, __pyx_k_ECDSA_P521_CERT01___reduce_cytho, sizeof(__pyx_k_ECDSA_P521_CERT01___reduce_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P521_CERT01___setstate_cyt, __pyx_k_ECDSA_P521_CERT01___setstate_cyt, sizeof(__pyx_k_ECDSA_P521_CERT01___setstate_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P521___reduce_cython, __pyx_k_ECDSA_P521___reduce_cython, sizeof(__pyx_k_ECDSA_P521___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ECDSA_P521___setstate_cython, __pyx_k_ECDSA_P521___setstate_cython, sizeof(__pyx_k_ECDSA_P521___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ED25519Key, __pyx_k_ED25519Key, sizeof(__pyx_k_ED25519Key), 0, 0, 1, 1}, + {&__pyx_n_s_ED25519Key___reduce_cython, __pyx_k_ED25519Key___reduce_cython, sizeof(__pyx_k_ED25519Key___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ED25519Key___setstate_cython, __pyx_k_ED25519Key___setstate_cython, sizeof(__pyx_k_ED25519Key___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ED25519_CERT01, __pyx_k_ED25519_CERT01, sizeof(__pyx_k_ED25519_CERT01), 0, 0, 1, 1}, + {&__pyx_n_s_ED25519_CERT01___reduce_cython, __pyx_k_ED25519_CERT01___reduce_cython, sizeof(__pyx_k_ED25519_CERT01___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ED25519_CERT01___setstate_cython, __pyx_k_ED25519_CERT01___setstate_cython, sizeof(__pyx_k_ED25519_CERT01___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_KeyType, __pyx_k_KeyType, sizeof(__pyx_k_KeyType), 0, 0, 1, 1}, + {&__pyx_n_s_KeyType___reduce_cython, __pyx_k_KeyType___reduce_cython, sizeof(__pyx_k_KeyType___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_KeyType___setstate_cython, __pyx_k_KeyType___setstate_cython, sizeof(__pyx_k_KeyType___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_RSA1Key, __pyx_k_RSA1Key, sizeof(__pyx_k_RSA1Key), 0, 0, 1, 1}, + {&__pyx_n_s_RSA1Key___reduce_cython, __pyx_k_RSA1Key___reduce_cython, sizeof(__pyx_k_RSA1Key___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_RSA1Key___setstate_cython, __pyx_k_RSA1Key___setstate_cython, sizeof(__pyx_k_RSA1Key___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_RSACert01Key, __pyx_k_RSACert01Key, sizeof(__pyx_k_RSACert01Key), 0, 0, 1, 1}, + {&__pyx_n_s_RSACert01Key___reduce_cython, __pyx_k_RSACert01Key___reduce_cython, sizeof(__pyx_k_RSACert01Key___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_RSACert01Key___setstate_cython, __pyx_k_RSACert01Key___setstate_cython, sizeof(__pyx_k_RSACert01Key___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_RSAKey, __pyx_k_RSAKey, sizeof(__pyx_k_RSAKey), 0, 0, 1, 1}, + {&__pyx_n_s_RSAKey___reduce_cython, __pyx_k_RSAKey___reduce_cython, sizeof(__pyx_k_RSAKey___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_RSAKey___setstate_cython, __pyx_k_RSAKey___setstate_cython, sizeof(__pyx_k_RSAKey___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_UnknownKey, __pyx_k_UnknownKey, sizeof(__pyx_k_UnknownKey), 0, 0, 1, 1}, + {&__pyx_n_s_UnknownKey___reduce_cython, __pyx_k_UnknownKey___reduce_cython, sizeof(__pyx_k_UnknownKey___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_UnknownKey___setstate_cython, __pyx_k_UnknownKey___setstate_cython, sizeof(__pyx_k_UnknownKey___setstate_cython), 0, 0, 1, 1}, + {&__pyx_kp_s_Unknown_keytype_s, __pyx_k_Unknown_keytype_s, sizeof(__pyx_k_Unknown_keytype_s), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s__37, __pyx_k__37, sizeof(__pyx_k__37), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_b_key_name, __pyx_k_b_key_name, sizeof(__pyx_k_b_key_name), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_key_name, __pyx_k_key_name, sizeof(__pyx_k_key_name), 0, 0, 1, 1}, + {&__pyx_n_s_key_name_2, __pyx_k_key_name_2, sizeof(__pyx_k_key_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_key_type_from_name, __pyx_k_key_type_from_name, sizeof(__pyx_k_key_type_from_name), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ssh_keytypes, __pyx_k_ssh_keytypes, sizeof(__pyx_k_ssh_keytypes), 0, 0, 1, 1}, + {&__pyx_kp_s_ssh_keytypes_pyx, __pyx_k_ssh_keytypes_pyx, sizeof(__pyx_k_ssh_keytypes_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_str, __pyx_k_str, sizeof(__pyx_k_str), 0, 0, 1, 1}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, + {&__pyx_n_s_unknown, __pyx_k_unknown, sizeof(__pyx_k_unknown), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 150, __pyx_L1_error) @@ -6844,314 +10591,257 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_L1_error:; return -1; } +/* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(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__") # <<<<<<<<<<<<<< + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); + __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); + __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); + __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); + __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); + __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__24); - __Pyx_GIVEREF(__pyx_tuple__24); + __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__25); - __Pyx_GIVEREF(__pyx_tuple__25); + __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__26); - __Pyx_GIVEREF(__pyx_tuple__26); + __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__27); - __Pyx_GIVEREF(__pyx_tuple__27); + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__28); - __Pyx_GIVEREF(__pyx_tuple__28); + __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__29); - __Pyx_GIVEREF(__pyx_tuple__29); + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__30); - __Pyx_GIVEREF(__pyx_tuple__30); + __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(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__") + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" */ - __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__31); - __Pyx_GIVEREF(__pyx_tuple__31); + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 3, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__32); - __Pyx_GIVEREF(__pyx_tuple__32); + __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 3, __pyx_L1_error) /* "ssh/keytypes.pyx":153 * @@ -7160,23 +10850,30 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef ssh_keytypes_e _type * cdef bytes b_key_name = to_bytes(key_name) */ - __pyx_tuple__33 = PyTuple_Pack(4, __pyx_n_s_key_name, __pyx_n_s_type, __pyx_n_s_b_key_name, __pyx_n_s_key_name_2); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(1, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__33); - __Pyx_GIVEREF(__pyx_tuple__33); - __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_keytypes_pyx, __pyx_n_s_key_type_from_name, 153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(1, 153, __pyx_L1_error) + __pyx_tuple__35 = PyTuple_Pack(4, __pyx_n_s_key_name, __pyx_n_s_type, __pyx_n_s_b_key_name, __pyx_n_s_key_name_2); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh_keytypes_pyx, __pyx_n_s_key_type_from_name, 153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(1, 153, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } +/* #### Code section: init_constants ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error); +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ @@ -7219,189 +10916,459 @@ static int __Pyx_modinit_function_export_code(void) { static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_KeyType) < 0) __PYX_ERR(1, 24, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_KeyType.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_KeyType.tp_dictoffset && __pyx_type_3ssh_8keytypes_KeyType.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_KeyType.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_KeyType, (PyObject *)&__pyx_type_3ssh_8keytypes_KeyType) < 0) __PYX_ERR(1, 24, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_KeyType) < 0) __PYX_ERR(1, 24, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_3ssh_8keytypes_KeyType = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_KeyType_spec, NULL); if (unlikely(!__pyx_ptype_3ssh_8keytypes_KeyType)) __PYX_ERR(1, 24, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_KeyType_spec, __pyx_ptype_3ssh_8keytypes_KeyType) < 0) __PYX_ERR(1, 24, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_KeyType = &__pyx_type_3ssh_8keytypes_KeyType; - __pyx_type_3ssh_8keytypes_DSSKey.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_DSSKey) < 0) __PYX_ERR(1, 48, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_DSSKey.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_DSSKey.tp_dictoffset && __pyx_type_3ssh_8keytypes_DSSKey.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_DSSKey.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_KeyType) < 0) __PYX_ERR(1, 24, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_KeyType->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_KeyType->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_KeyType->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_KeyType->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DSSKey, (PyObject *)&__pyx_type_3ssh_8keytypes_DSSKey) < 0) __PYX_ERR(1, 48, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_DSSKey) < 0) __PYX_ERR(1, 48, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_KeyType, (PyObject *) __pyx_ptype_3ssh_8keytypes_KeyType) < 0) __PYX_ERR(1, 24, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_KeyType) < 0) __PYX_ERR(1, 24, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_DSSKey = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_DSSKey_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_DSSKey)) __PYX_ERR(1, 48, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_DSSKey_spec, __pyx_ptype_3ssh_8keytypes_DSSKey) < 0) __PYX_ERR(1, 48, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_DSSKey = &__pyx_type_3ssh_8keytypes_DSSKey; - __pyx_type_3ssh_8keytypes_RSAKey.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_RSAKey) < 0) __PYX_ERR(1, 53, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_RSAKey.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_RSAKey.tp_dictoffset && __pyx_type_3ssh_8keytypes_RSAKey.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_RSAKey.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_DSSKey->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_DSSKey) < 0) __PYX_ERR(1, 48, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_DSSKey->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_DSSKey->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_DSSKey->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_DSSKey->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RSAKey, (PyObject *)&__pyx_type_3ssh_8keytypes_RSAKey) < 0) __PYX_ERR(1, 53, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_RSAKey) < 0) __PYX_ERR(1, 53, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DSSKey, (PyObject *) __pyx_ptype_3ssh_8keytypes_DSSKey) < 0) __PYX_ERR(1, 48, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_DSSKey) < 0) __PYX_ERR(1, 48, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_RSAKey = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_RSAKey_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_RSAKey)) __PYX_ERR(1, 53, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_RSAKey_spec, __pyx_ptype_3ssh_8keytypes_RSAKey) < 0) __PYX_ERR(1, 53, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_RSAKey = &__pyx_type_3ssh_8keytypes_RSAKey; - __pyx_type_3ssh_8keytypes_RSA1Key.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_RSA1Key) < 0) __PYX_ERR(1, 58, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_RSA1Key.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_RSA1Key.tp_dictoffset && __pyx_type_3ssh_8keytypes_RSA1Key.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_RSA1Key.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_RSAKey->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_RSAKey) < 0) __PYX_ERR(1, 53, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_RSAKey->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_RSAKey->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_RSAKey->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_RSAKey->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RSA1Key, (PyObject *)&__pyx_type_3ssh_8keytypes_RSA1Key) < 0) __PYX_ERR(1, 58, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_RSA1Key) < 0) __PYX_ERR(1, 58, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RSAKey, (PyObject *) __pyx_ptype_3ssh_8keytypes_RSAKey) < 0) __PYX_ERR(1, 53, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_RSAKey) < 0) __PYX_ERR(1, 53, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_RSA1Key = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_RSA1Key_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_RSA1Key)) __PYX_ERR(1, 58, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_RSA1Key_spec, __pyx_ptype_3ssh_8keytypes_RSA1Key) < 0) __PYX_ERR(1, 58, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_RSA1Key = &__pyx_type_3ssh_8keytypes_RSA1Key; - __pyx_type_3ssh_8keytypes_ECDSAKey.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ECDSAKey) < 0) __PYX_ERR(1, 63, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ECDSAKey.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ECDSAKey.tp_dictoffset && __pyx_type_3ssh_8keytypes_ECDSAKey.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ECDSAKey.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_RSA1Key->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_RSA1Key) < 0) __PYX_ERR(1, 58, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_RSA1Key->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_RSA1Key->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_RSA1Key->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_RSA1Key->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSAKey, (PyObject *)&__pyx_type_3ssh_8keytypes_ECDSAKey) < 0) __PYX_ERR(1, 63, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ECDSAKey) < 0) __PYX_ERR(1, 63, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RSA1Key, (PyObject *) __pyx_ptype_3ssh_8keytypes_RSA1Key) < 0) __PYX_ERR(1, 58, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_RSA1Key) < 0) __PYX_ERR(1, 58, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ECDSAKey = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ECDSAKey_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ECDSAKey)) __PYX_ERR(1, 63, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ECDSAKey_spec, __pyx_ptype_3ssh_8keytypes_ECDSAKey) < 0) __PYX_ERR(1, 63, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ECDSAKey = &__pyx_type_3ssh_8keytypes_ECDSAKey; - __pyx_type_3ssh_8keytypes_DSSCert01Key.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_DSSCert01Key) < 0) __PYX_ERR(1, 68, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_DSSCert01Key.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_DSSCert01Key.tp_dictoffset && __pyx_type_3ssh_8keytypes_DSSCert01Key.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_DSSCert01Key.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ECDSAKey->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ECDSAKey) < 0) __PYX_ERR(1, 63, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ECDSAKey->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ECDSAKey->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ECDSAKey->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ECDSAKey->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DSSCert01Key, (PyObject *)&__pyx_type_3ssh_8keytypes_DSSCert01Key) < 0) __PYX_ERR(1, 68, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_DSSCert01Key) < 0) __PYX_ERR(1, 68, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSAKey, (PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSAKey) < 0) __PYX_ERR(1, 63, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSAKey) < 0) __PYX_ERR(1, 63, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_DSSCert01Key = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_DSSCert01Key_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_DSSCert01Key)) __PYX_ERR(1, 68, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_DSSCert01Key_spec, __pyx_ptype_3ssh_8keytypes_DSSCert01Key) < 0) __PYX_ERR(1, 68, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_DSSCert01Key = &__pyx_type_3ssh_8keytypes_DSSCert01Key; - __pyx_type_3ssh_8keytypes_RSACert01Key.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_RSACert01Key) < 0) __PYX_ERR(1, 73, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_RSACert01Key.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_RSACert01Key.tp_dictoffset && __pyx_type_3ssh_8keytypes_RSACert01Key.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_RSACert01Key.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_DSSCert01Key->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_DSSCert01Key) < 0) __PYX_ERR(1, 68, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_DSSCert01Key->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_DSSCert01Key->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_DSSCert01Key->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_DSSCert01Key->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RSACert01Key, (PyObject *)&__pyx_type_3ssh_8keytypes_RSACert01Key) < 0) __PYX_ERR(1, 73, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_RSACert01Key) < 0) __PYX_ERR(1, 73, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DSSCert01Key, (PyObject *) __pyx_ptype_3ssh_8keytypes_DSSCert01Key) < 0) __PYX_ERR(1, 68, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_DSSCert01Key) < 0) __PYX_ERR(1, 68, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_RSACert01Key = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_RSACert01Key_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_RSACert01Key)) __PYX_ERR(1, 73, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_RSACert01Key_spec, __pyx_ptype_3ssh_8keytypes_RSACert01Key) < 0) __PYX_ERR(1, 73, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_RSACert01Key = &__pyx_type_3ssh_8keytypes_RSACert01Key; - __pyx_type_3ssh_8keytypes_ECDSA_P256.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ECDSA_P256) < 0) __PYX_ERR(1, 78, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ECDSA_P256.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ECDSA_P256.tp_dictoffset && __pyx_type_3ssh_8keytypes_ECDSA_P256.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ECDSA_P256.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_RSACert01Key->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_RSACert01Key) < 0) __PYX_ERR(1, 73, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_RSACert01Key->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_RSACert01Key->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_RSACert01Key->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_RSACert01Key->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P256, (PyObject *)&__pyx_type_3ssh_8keytypes_ECDSA_P256) < 0) __PYX_ERR(1, 78, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ECDSA_P256) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RSACert01Key, (PyObject *) __pyx_ptype_3ssh_8keytypes_RSACert01Key) < 0) __PYX_ERR(1, 73, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_RSACert01Key) < 0) __PYX_ERR(1, 73, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ECDSA_P256 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ECDSA_P256_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P256)) __PYX_ERR(1, 78, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ECDSA_P256_spec, __pyx_ptype_3ssh_8keytypes_ECDSA_P256) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ECDSA_P256 = &__pyx_type_3ssh_8keytypes_ECDSA_P256; - __pyx_type_3ssh_8keytypes_ECDSA_P384.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ECDSA_P384) < 0) __PYX_ERR(1, 83, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ECDSA_P384.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ECDSA_P384.tp_dictoffset && __pyx_type_3ssh_8keytypes_ECDSA_P384.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ECDSA_P384.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ECDSA_P256->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ECDSA_P256) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ECDSA_P256->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P256->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ECDSA_P256->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ECDSA_P256->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P384, (PyObject *)&__pyx_type_3ssh_8keytypes_ECDSA_P384) < 0) __PYX_ERR(1, 83, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ECDSA_P384) < 0) __PYX_ERR(1, 83, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P256, (PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P256) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P256) < 0) __PYX_ERR(1, 78, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ECDSA_P384 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ECDSA_P384_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P384)) __PYX_ERR(1, 83, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ECDSA_P384_spec, __pyx_ptype_3ssh_8keytypes_ECDSA_P384) < 0) __PYX_ERR(1, 83, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ECDSA_P384 = &__pyx_type_3ssh_8keytypes_ECDSA_P384; - __pyx_type_3ssh_8keytypes_ECDSA_P521.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ECDSA_P521) < 0) __PYX_ERR(1, 88, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ECDSA_P521.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ECDSA_P521.tp_dictoffset && __pyx_type_3ssh_8keytypes_ECDSA_P521.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ECDSA_P521.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ECDSA_P384->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ECDSA_P384) < 0) __PYX_ERR(1, 83, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ECDSA_P384->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P384->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ECDSA_P384->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ECDSA_P384->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P521, (PyObject *)&__pyx_type_3ssh_8keytypes_ECDSA_P521) < 0) __PYX_ERR(1, 88, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ECDSA_P521) < 0) __PYX_ERR(1, 88, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P384, (PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P384) < 0) __PYX_ERR(1, 83, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P384) < 0) __PYX_ERR(1, 83, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ECDSA_P521 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ECDSA_P521_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P521)) __PYX_ERR(1, 88, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ECDSA_P521_spec, __pyx_ptype_3ssh_8keytypes_ECDSA_P521) < 0) __PYX_ERR(1, 88, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ECDSA_P521 = &__pyx_type_3ssh_8keytypes_ECDSA_P521; - __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01) < 0) __PYX_ERR(1, 93, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01.tp_dictoffset && __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ECDSA_P521->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ECDSA_P521) < 0) __PYX_ERR(1, 88, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ECDSA_P521->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P521->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ECDSA_P521->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ECDSA_P521->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P256_CERT01, (PyObject *)&__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01) < 0) __PYX_ERR(1, 93, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01) < 0) __PYX_ERR(1, 93, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P521, (PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P521) < 0) __PYX_ERR(1, 88, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P521) < 0) __PYX_ERR(1, 88, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01)) __PYX_ERR(1, 93, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01_spec, __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01) < 0) __PYX_ERR(1, 93, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01 = &__pyx_type_3ssh_8keytypes_ECDSA_P256_CERT01; - __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01) < 0) __PYX_ERR(1, 98, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01.tp_dictoffset && __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01) < 0) __PYX_ERR(1, 93, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P384_CERT01, (PyObject *)&__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01) < 0) __PYX_ERR(1, 98, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01) < 0) __PYX_ERR(1, 98, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P256_CERT01, (PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01) < 0) __PYX_ERR(1, 93, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P256_CERT01) < 0) __PYX_ERR(1, 93, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01)) __PYX_ERR(1, 98, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01_spec, __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01) < 0) __PYX_ERR(1, 98, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01 = &__pyx_type_3ssh_8keytypes_ECDSA_P384_CERT01; - __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01) < 0) __PYX_ERR(1, 103, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01.tp_dictoffset && __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01) < 0) __PYX_ERR(1, 98, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P521_CERT01, (PyObject *)&__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01) < 0) __PYX_ERR(1, 103, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01) < 0) __PYX_ERR(1, 103, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P384_CERT01, (PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01) < 0) __PYX_ERR(1, 98, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P384_CERT01) < 0) __PYX_ERR(1, 98, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01)) __PYX_ERR(1, 103, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01_spec, __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01) < 0) __PYX_ERR(1, 103, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01 = &__pyx_type_3ssh_8keytypes_ECDSA_P521_CERT01; - __pyx_type_3ssh_8keytypes_ED25519_CERT01.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ED25519_CERT01) < 0) __PYX_ERR(1, 113, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ED25519_CERT01.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ED25519_CERT01.tp_dictoffset && __pyx_type_3ssh_8keytypes_ED25519_CERT01.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ED25519_CERT01.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01) < 0) __PYX_ERR(1, 103, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ED25519_CERT01, (PyObject *)&__pyx_type_3ssh_8keytypes_ED25519_CERT01) < 0) __PYX_ERR(1, 113, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ED25519_CERT01) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ECDSA_P521_CERT01, (PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01) < 0) __PYX_ERR(1, 103, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ECDSA_P521_CERT01) < 0) __PYX_ERR(1, 103, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ED25519_CERT01 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ED25519_CERT01_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ED25519_CERT01)) __PYX_ERR(1, 113, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ED25519_CERT01_spec, __pyx_ptype_3ssh_8keytypes_ED25519_CERT01) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ED25519_CERT01 = &__pyx_type_3ssh_8keytypes_ED25519_CERT01; - __pyx_type_3ssh_8keytypes_UnknownKey.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_UnknownKey) < 0) __PYX_ERR(1, 43, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_UnknownKey.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_UnknownKey.tp_dictoffset && __pyx_type_3ssh_8keytypes_UnknownKey.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_UnknownKey.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ED25519_CERT01->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ED25519_CERT01) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ED25519_CERT01->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ED25519_CERT01->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ED25519_CERT01->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ED25519_CERT01->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UnknownKey, (PyObject *)&__pyx_type_3ssh_8keytypes_UnknownKey) < 0) __PYX_ERR(1, 43, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_UnknownKey) < 0) __PYX_ERR(1, 43, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ED25519_CERT01, (PyObject *) __pyx_ptype_3ssh_8keytypes_ED25519_CERT01) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ED25519_CERT01) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_UnknownKey = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_UnknownKey_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_UnknownKey)) __PYX_ERR(1, 43, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_UnknownKey_spec, __pyx_ptype_3ssh_8keytypes_UnknownKey) < 0) __PYX_ERR(1, 43, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_UnknownKey = &__pyx_type_3ssh_8keytypes_UnknownKey; - __pyx_type_3ssh_8keytypes_ED25519Key.tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; - if (PyType_Ready(&__pyx_type_3ssh_8keytypes_ED25519Key) < 0) __PYX_ERR(1, 108, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_3ssh_8keytypes_ED25519Key.tp_print = 0; #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_3ssh_8keytypes_ED25519Key.tp_dictoffset && __pyx_type_3ssh_8keytypes_ED25519Key.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_3ssh_8keytypes_ED25519Key.tp_getattro = __Pyx_PyObject_GenericGetAttr; + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_UnknownKey->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_UnknownKey) < 0) __PYX_ERR(1, 43, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_UnknownKey->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_UnknownKey->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_UnknownKey->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_UnknownKey->tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ED25519Key, (PyObject *)&__pyx_type_3ssh_8keytypes_ED25519Key) < 0) __PYX_ERR(1, 108, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_3ssh_8keytypes_ED25519Key) < 0) __PYX_ERR(1, 108, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UnknownKey, (PyObject *) __pyx_ptype_3ssh_8keytypes_UnknownKey) < 0) __PYX_ERR(1, 43, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_UnknownKey) < 0) __PYX_ERR(1, 43, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_3ssh_8keytypes_KeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_3ssh_8keytypes_ED25519Key = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_3ssh_8keytypes_ED25519Key_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_3ssh_8keytypes_ED25519Key)) __PYX_ERR(1, 108, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_3ssh_8keytypes_ED25519Key_spec, __pyx_ptype_3ssh_8keytypes_ED25519Key) < 0) __PYX_ERR(1, 108, __pyx_L1_error) + #else __pyx_ptype_3ssh_8keytypes_ED25519Key = &__pyx_type_3ssh_8keytypes_ED25519Key; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_3ssh_8keytypes_ED25519Key->tp_base = __pyx_ptype_3ssh_8keytypes_KeyType; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_3ssh_8keytypes_ED25519Key) < 0) __PYX_ERR(1, 108, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_3ssh_8keytypes_ED25519Key->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_3ssh_8keytypes_ED25519Key->tp_dictoffset && __pyx_ptype_3ssh_8keytypes_ED25519Key->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_3ssh_8keytypes_ED25519Key->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ED25519Key, (PyObject *) __pyx_ptype_3ssh_8keytypes_ED25519Key) < 0) __PYX_ERR(1, 108, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_3ssh_8keytypes_ED25519Key) < 0) __PYX_ERR(1, 108, __pyx_L1_error) + #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } @@ -7432,8 +11399,8 @@ static int __Pyx_modinit_function_import_code(void) { /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("ssh.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_3ssh_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_3ssh_5utils_to_str, "PyObject *(char const *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_3ssh_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_3ssh_5utils_to_str, "PyObject *(char const *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -7444,11 +11411,60 @@ static int __Pyx_modinit_function_import_code(void) { } -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_keytypes(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_keytypes}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "keytypes", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif @@ -7494,12 +11510,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { } return 0; } -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else result = PyDict_SetItemString(moddict, to_name, value); +#endif } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { @@ -7509,8 +11534,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) @@ -7520,8 +11546,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; +#endif if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; @@ -7537,7 +11567,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_keytypes(PyObject *__pyx_pyinit_mo #endif #endif { + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -7551,6 +11586,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_keytypes(PyObject *__pyx_pyinit_mo #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("keytypes", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "keytypes" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { @@ -7561,7 +11623,7 @@ if (!__Pyx_RefNanny) { } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_keytypes(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif @@ -7569,48 +11631,31 @@ if (!__Pyx_RefNanny) { __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("keytypes", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + stringtab_initialized = 1; if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error) @@ -7622,7 +11667,7 @@ if (!__Pyx_RefNanny) { { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "ssh.keytypes")) { - if (unlikely(PyDict_SetItemString(modules, "ssh.keytypes", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((PyDict_SetItemString(modules, "ssh.keytypes", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error) } } #endif @@ -7633,176 +11678,928 @@ if (!__Pyx_RefNanny) { /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); - if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error) - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error) (void)__Pyx_modinit_type_import_code(); (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error) /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif - /* "ssh/keytypes.pyx":153 - * - * - * def key_type_from_name(key_name): # <<<<<<<<<<<<<< - * cdef ssh_keytypes_e _type - * cdef bytes b_key_name = to_bytes(key_name) + /* "(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_1 = PyCFunction_NewEx(&__pyx_mdef_3ssh_8keytypes_1key_type_from_name, NULL, __pyx_n_s_ssh_keytypes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_key_type_from_name, __pyx_t_1) < 0) __PYX_ERR(1, 153, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_7KeyType_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KeyType___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "ssh/keytypes.pyx":1 - * # This file is part of ssh-python. # <<<<<<<<<<<<<< - * # Copyright (C) 2018-2020 Panos Kittenis - * # + /* "(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_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /*--- Wrapped vars code ---*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_7KeyType_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KeyType___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init ssh.keytypes", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init ssh.keytypes"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} + /* "(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_3ssh_8keytypes_10UnknownKey_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_UnknownKey___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -/* --- 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 + /* "(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_3ssh_8keytypes_10UnknownKey_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_UnknownKey___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif + /* "(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_3ssh_8keytypes_6DSSKey_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_DSSKey___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} + /* "(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_3ssh_8keytypes_6DSSKey_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_DSSKey___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -/* 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); -} + /* "(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_3ssh_8keytypes_6RSAKey_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_RSAKey___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kwdict, - const char* function_name, - int kw_allowed) -{ - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) - goto invalid_keyword; - return 1; -#else - while (PyDict_Next(kwdict, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } - if ((!kw_allowed) && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; -#endif -invalid_keyword: - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION < 3 - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif - return 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_3ssh_8keytypes_6RSAKey_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_RSAKey___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL + /* "(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_3ssh_8keytypes_7RSA1Key_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_RSA1Key___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "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_3ssh_8keytypes_7RSA1Key_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_RSA1Key___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(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_3ssh_8keytypes_8ECDSAKey_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSAKey___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_8ECDSAKey_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSAKey___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_12DSSCert01Key_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_DSSCert01Key___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_12DSSCert01Key_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_DSSCert01Key___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(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_3ssh_8keytypes_12RSACert01Key_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_RSACert01Key___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_12RSACert01Key_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_RSACert01Key___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(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_3ssh_8keytypes_10ECDSA_P256_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P256___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_10ECDSA_P256_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P256___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_10ECDSA_P384_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P384___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_10ECDSA_P384_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P384___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_10ECDSA_P521_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P521___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_10ECDSA_P521_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P521___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_17ECDSA_P256_CERT01_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P256_CERT01___reduce_cytho, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_17ECDSA_P256_CERT01_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P256_CERT01___setstate_cyt, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_17ECDSA_P384_CERT01_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P384_CERT01___reduce_cytho, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_17ECDSA_P384_CERT01_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P384_CERT01___setstate_cyt, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_17ECDSA_P521_CERT01_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P521_CERT01___reduce_cytho, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_17ECDSA_P521_CERT01_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ECDSA_P521_CERT01___setstate_cyt, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_10ED25519Key_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ED25519Key___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_10ED25519Key_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ED25519Key___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_14ED25519_CERT01_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ED25519_CERT01___reduce_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_14ED25519_CERT01_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ED25519_CERT01___setstate_cython, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "ssh/keytypes.pyx":153 + * + * + * def key_type_from_name(key_name): # <<<<<<<<<<<<<< + * cdef ssh_keytypes_e _type + * cdef bytes b_key_name = to_bytes(key_name) + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_3ssh_8keytypes_1key_type_from_name, 0, __pyx_n_s_key_type_from_name, NULL, __pyx_n_s_ssh_keytypes, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_key_type_from_name, __pyx_t_2) < 0) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "ssh/keytypes.pyx":1 + * # This file is part of ssh-python. # <<<<<<<<<<<<<< + * # Copyright (C) 2018-2020 Panos Kittenis + * # + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init ssh.keytypes", __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 ssh.keytypes"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; irecursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; + #endif + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); + } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { + #if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + Py_XDECREF(key); + Py_XDECREF(value); + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#endif + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; } -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; #endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { - return NULL; + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); } - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} #endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; + +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; } } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); } - nk = i / 2; } - else { - kwtuple = NULL; - k = NULL; + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); + 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 - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} +#endif + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; } - else { - d = NULL; - nd = 0; + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} #else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; #endif - Py_XDECREF(kwtuple); + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; done: - Py_LeaveRecursiveCall(); - return result; + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; } #endif -#endif -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); } - return result; -} -#endif - -/* PyObjectCallMethO */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); 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; + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif -/* PyObjectCallNoArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} #endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) +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 - if (likely(PyCFunction_Check(func))) + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; } +#endif } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); -} -#endif - -/* PyCFunctionFastCall */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; } +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #endif - -/* PyObjectCallOneArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); + if (unlikely(op->func_name == NULL)) + return NULL; } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) #endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (__Pyx_PyFastCFunction_Check(func)) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif - } + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; } - return __Pyx__PyObject_CallOneArg(func, arg); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; } -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; } +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) #endif - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; } -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; +static 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 - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { - __Pyx_PyThreadState_declare - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; } -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { +static 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, - "raise: arg 3 must be a traceback or None"); - goto bad; + "__defaults__ must be set to a tuple object"); + return -1; } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; - } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; } - } else { + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; + "__kwdefaults__ must be set to a dict object"); + return -1; } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; + result = Py_None; } - PyException_SetCause(value, fixed_cause); } - PyErr_SetObject(type, value); - if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); #else - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; } #endif + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); } -bad: - Py_XDECREF(owned_instance); - return; +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); } #endif - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); #if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); + Py_INCREF(m->func_qualname); + return m->func_qualname; #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); #endif - return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); } - return descr; -} #endif - -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); + return 0; } +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; ifunc_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); #endif - for (i=0; idefaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); } return 0; } -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { - PyObject *exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif } +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; #endif - -/* PyObjectGetAttrStrNoError */ -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + 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; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif } #endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); } return result; } - -/* SetupReduce */ -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } + return def->ml_meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), #endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, #else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } + 0, #endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + offsetof(PyCFunctionObject, m_weakreflist), #endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_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; + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } /* PyDictVersioning */ @@ -8457,12 +14917,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -8476,7 +14937,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); @@ -8498,6 +14959,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { @@ -8576,17 +15038,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -8621,6 +15167,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -8636,7 +15183,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -8683,6 +15230,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__ssh_keytypes_e(enum ssh_keytypes_e value) { @@ -8717,10 +15265,52 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__ssh_keytypes_e(enum ssh_ke { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(enum ssh_keytypes_e), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(enum ssh_keytypes_e)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__37); } + return name; } +#endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { @@ -8755,8 +15345,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -8795,7 +15411,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -8809,40 +15425,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -8855,109 +15476,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -8991,7 +15684,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -9005,40 +15698,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -9051,109 +15749,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -9178,7 +15948,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -9199,6 +15969,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -9223,11 +16009,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -9275,41 +16061,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* FunctionExport */ @@ -9331,11 +16126,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s goto bad; } tmp.fp = f; -#if PY_VERSION_HEX >= 0x02070000 cobj = PyCapsule_New(tmp.p, sig, 0); -#else - cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); -#endif if (!cobj) goto bad; if (PyDict_SetItemString(d, name, cobj) < 0) @@ -9350,9 +16141,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s } /* FunctionImport */ -#ifndef __PYX_HAVE_RT_ImportFunction -#define __PYX_HAVE_RT_ImportFunction -static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { +#ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 +#define __PYX_HAVE_RT_ImportFunction_3_0_10 +static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { @@ -9369,7 +16160,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** PyModule_GetName(module), funcname); goto bad; } -#if PY_VERSION_HEX >= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", @@ -9377,21 +16167,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); -#else - {const char *desc, *s1, *s2; - desc = (const char *)PyCObject_GetDesc(cobj); - if (!desc) - goto bad; - s1 = desc; s2 = sig; - while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } - if (*s1 != *s2) { - PyErr_Format(PyExc_TypeError, - "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", - PyModule_GetName(module), funcname, sig, desc); - goto bad; - } - tmp.p = PyCObject_AsVoidPtr(cobj);} -#endif *f = tmp.fp; if (!(*f)) goto bad; @@ -9404,9 +16179,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (** #endif /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -9414,30 +16211,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -9492,7 +16293,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -9521,22 +16322,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -9602,13 +16407,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -9676,4 +16479,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/ssh/options.c b/ssh/options.c index f0b3df4c..0b14666a 100644 --- a/ssh/options.c +++ b/ssh/options.c @@ -1,22 +1,72 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "local/include/libssh/libssh.h" + ], + "extra_compile_args": [ + "-O2", + "-g0", + "-s" + ], + "include_dirs": [ + "./local/include", + "./libssh/include" + ], + "libraries": [ + "ssh" + ], + "library_dirs": [ + "/home/josykes/PycharmProjects/ssh-python/local/lib" + ], + "name": "ssh.options", + "runtime_library_dirs": [ + "$ORIGIN/." + ], + "sources": [ + "ssh/options.pyx" + ] + }, + "module_name": "ssh.options" +} +END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -35,9 +85,7 @@ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -45,13 +93,19 @@ #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -76,10 +130,19 @@ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -87,46 +150,127 @@ #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_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 + #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_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -134,19 +278,28 @@ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS @@ -154,8 +307,6 @@ #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif @@ -167,11 +318,22 @@ #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif @@ -179,18 +341,25 @@ #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif #else #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -199,10 +368,7 @@ #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -226,37 +392,62 @@ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -285,6 +476,17 @@ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -298,13 +500,16 @@ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -312,28 +517,59 @@ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -343,13 +579,26 @@ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -365,85 +614,145 @@ #endif #endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + 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 (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif - #define __Pyx_DefaultClassType PyType_Type +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -457,6 +766,12 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -468,34 +783,89 @@ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} #endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else -#define __Pyx_PyFastCFunction_Check(func) 0 + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -503,6 +873,22 @@ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -533,7 +919,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -545,34 +953,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #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 + #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 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -582,11 +1047,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -597,14 +1062,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) @@ -633,8 +1104,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -644,15 +1121,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -664,6 +1168,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -681,11 +1188,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods @@ -726,11 +1228,20 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -793,9 +1304,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -813,9 +1325,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) @@ -823,13 +1335,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -853,8 +1359,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -875,7 +1427,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -905,6 +1457,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -940,23 +1493,29 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "ssh/options.pyx", - "stringsource", + "", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_3ssh_7options_Option; @@ -988,6 +1547,7 @@ struct __pyx_vtabstruct_3ssh_7options_Option { struct __pyx_obj_3ssh_7options_Option *(*from_option)(enum ssh_options_e); }; static struct __pyx_vtabstruct_3ssh_7options_Option *__pyx_vtabptr_3ssh_7options_Option; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -996,11 +1556,11 @@ static struct __pyx_vtabstruct_3ssh_7options_Option *__pyx_vtabptr_3ssh_7options #endif #if CYTHON_REFNANNY typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1010,28 +1570,40 @@ static struct __pyx_vtabstruct_3ssh_7options_Option *__pyx_vtabptr_3ssh_7options #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1042,6 +1614,10 @@ static struct __pyx_vtabstruct_3ssh_7options_Option *__pyx_vtabptr_3ssh_7options #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);\ @@ -1053,48 +1629,120 @@ static struct __pyx_vtabstruct_3ssh_7options_Option *__pyx_vtabptr_3ssh_7options #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) +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +/* PyObject_Str.proto */ +#define __Pyx_PyObject_Str(obj)\ + (likely(PyString_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#else -#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif -#if CYTHON_FAST_PYCALL - static size_t __pyx_pyframe_localsplus_offset = 0; +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif // CYTHON_FAST_PYCALL +#endif +#endif #endif /* PyObjectCall.proto */ @@ -1109,22 +1757,16 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif +/* 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); -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) -#endif +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE @@ -1138,11 +1780,18 @@ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tsta #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1154,7 +1803,7 @@ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tsta #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1170,12 +1819,12 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); - /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); @@ -1207,18 +1856,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) @@ -1226,18 +1875,18 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name); +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); @@ -1250,14 +1899,46 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); - /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + /* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 @@ -1274,13 +1955,160 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK @@ -1290,6 +2118,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1303,13 +2132,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif @@ -1325,47 +2155,72 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ static struct __pyx_obj_3ssh_7options_Option *__pyx_f_3ssh_7options_6Option_from_option(enum ssh_options_e __pyx_v_option); /* proto*/ -/* Module declarations from 'libc.stddef' */ +/* Module declarations from "libc.stddef" */ -/* Module declarations from 'libc.time' */ +/* Module declarations from "libc.time" */ -/* Module declarations from 'posix.types' */ +/* Module declarations from "posix.types" */ -/* Module declarations from 'ssh.c_ssh' */ +/* Module declarations from "ssh.c_ssh" */ -/* Module declarations from 'ssh.options' */ -static PyTypeObject *__pyx_ptype_3ssh_7options_Option = 0; +/* Module declarations from "ssh.options" */ static PyObject *__pyx_f_3ssh_7options___pyx_unpickle_Option__set_state(struct __pyx_obj_3ssh_7options_Option *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "ssh.options" extern int __pyx_module_is_main_ssh__options; int __pyx_module_is_main_ssh__options = 0; -/* Implementation of 'ssh.options' */ +/* Implementation of "ssh.options" */ +/* #### Code section: global_var ### */ +/* #### Code section: string_decls ### */ static const char __pyx_k_FD[] = "FD"; +static const char __pyx_k__2[] = "."; +static const char __pyx_k__9[] = "?"; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_str[] = "__str__"; static const char __pyx_k_HOST[] = "HOST"; @@ -1376,8 +2231,12 @@ static const char __pyx_k_USER[] = "USER"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_self[] = "self"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_state[] = "state"; static const char __pyx_k_Option[] = "Option"; +static const char __pyx_k_dict_2[] = "_dict"; +static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; @@ -1385,6 +2244,7 @@ static const char __pyx_k_update[] = "update"; static const char __pyx_k_NODELAY[] = "NODELAY"; static const char __pyx_k_SSH_DIR[] = "SSH_DIR"; static const char __pyx_k_TIMEOUT[] = "TIMEOUT"; +static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_BINDADDR[] = "BINDADDR"; static const char __pyx_k_HMAC_C_S[] = "HMAC_C_S"; static const char __pyx_k_HMAC_S_C[] = "HMAC_S_C"; @@ -1394,6 +2254,7 @@ static const char __pyx_k_PORT_STR[] = "PORT_STR"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_KNOWNHOSTS[] = "KNOWNHOSTS"; @@ -1413,8 +2274,10 @@ static const char __pyx_k_ADD_IDENTITY[] = "ADD_IDENTITY"; static const char __pyx_k_KEY_EXCHANGE[] = "KEY_EXCHANGE"; static const char __pyx_k_PROXYCOMMAND[] = "PROXYCOMMAND"; static const char __pyx_k_TIMEOUT_USEC[] = "TIMEOUT_USEC"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_use_setstate[] = "use_setstate"; static const char __pyx_k_LOG_VERBOSITY[] = "LOG_VERBOSITY"; static const char __pyx_k_PASSWORD_AUTH[] = "PASSWORD_AUTH"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; @@ -1427,82 +2290,17 @@ static const char __pyx_k_COMPRESSION_LEVEL[] = "COMPRESSION_LEVEL"; static const char __pyx_k_GLOBAL_KNOWNHOSTS[] = "GLOBAL_KNOWNHOSTS"; static const char __pyx_k_LOG_VERBOSITY_STR[] = "LOG_VERBOSITY_STR"; static const char __pyx_k_STRICTHOSTKEYCHECK[] = "STRICTHOSTKEYCHECK"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_pyx_unpickle_Option[] = "__pyx_unpickle_Option"; static const char __pyx_k_GSSAPI_CLIENT_IDENTITY[] = "GSSAPI_CLIENT_IDENTITY"; static const char __pyx_k_GSSAPI_SERVER_IDENTITY[] = "GSSAPI_SERVER_IDENTITY"; +static const char __pyx_k_Option___reduce_cython[] = "Option.__reduce_cython__"; +static const char __pyx_k_Option___setstate_cython[] = "Option.__setstate_cython__"; static const char __pyx_k_PUBLICKEY_ACCEPTED_TYPES[] = "PUBLICKEY_ACCEPTED_TYPES"; static const char __pyx_k_GSSAPI_DELEGATE_CREDENTIALS[] = "GSSAPI_DELEGATE_CREDENTIALS"; -static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x80dcc6c, 0x3b84bd8, 0x59348e4) = (_option))"; -static PyObject *__pyx_n_s_ADD_IDENTITY; -static PyObject *__pyx_n_s_BINDADDR; -static PyObject *__pyx_n_s_CIPHERS_C_S; -static PyObject *__pyx_n_s_CIPHERS_S_C; -static PyObject *__pyx_n_s_COMPRESSION; -static PyObject *__pyx_n_s_COMPRESSION_C_S; -static PyObject *__pyx_n_s_COMPRESSION_LEVEL; -static PyObject *__pyx_n_s_COMPRESSION_S_C; -static PyObject *__pyx_n_s_FD; -static PyObject *__pyx_n_s_GLOBAL_KNOWNHOSTS; -static PyObject *__pyx_n_s_GSSAPI_AUTH; -static PyObject *__pyx_n_s_GSSAPI_CLIENT_IDENTITY; -static PyObject *__pyx_n_s_GSSAPI_DELEGATE_CREDENTIALS; -static PyObject *__pyx_n_s_GSSAPI_SERVER_IDENTITY; -static PyObject *__pyx_n_s_HMAC_C_S; -static PyObject *__pyx_n_s_HMAC_S_C; -static PyObject *__pyx_n_s_HOST; -static PyObject *__pyx_n_s_HOSTKEYS; -static PyObject *__pyx_n_s_IDENTITY; -static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; -static PyObject *__pyx_n_s_KBDINT_AUTH; -static PyObject *__pyx_n_s_KEY_EXCHANGE; -static PyObject *__pyx_n_s_KNOWNHOSTS; -static PyObject *__pyx_n_s_LOG_VERBOSITY; -static PyObject *__pyx_n_s_LOG_VERBOSITY_STR; -static PyObject *__pyx_n_s_NODELAY; -static PyObject *__pyx_n_s_Option; -static PyObject *__pyx_n_s_PASSWORD_AUTH; -static PyObject *__pyx_n_s_PORT; -static PyObject *__pyx_n_s_PORT_STR; -static PyObject *__pyx_n_s_PROCESS_CONFIG; -static PyObject *__pyx_n_s_PROXYCOMMAND; -static PyObject *__pyx_n_s_PUBKEY_AUTH; -static PyObject *__pyx_n_s_PUBLICKEY_ACCEPTED_TYPES; -static PyObject *__pyx_n_s_PickleError; -static PyObject *__pyx_n_s_REKEY_DATA; -static PyObject *__pyx_n_s_REKEY_TIME; -static PyObject *__pyx_n_s_SSH1; -static PyObject *__pyx_n_s_SSH2; -static PyObject *__pyx_n_s_SSH_DIR; -static PyObject *__pyx_n_s_STRICTHOSTKEYCHECK; -static PyObject *__pyx_n_s_TIMEOUT; -static PyObject *__pyx_n_s_TIMEOUT_USEC; -static PyObject *__pyx_n_s_USER; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_dict; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_new; -static PyObject *__pyx_n_s_pickle; -static PyObject *__pyx_n_s_pyx_PickleError; -static PyObject *__pyx_n_s_pyx_checksum; -static PyObject *__pyx_n_s_pyx_result; -static PyObject *__pyx_n_s_pyx_state; -static PyObject *__pyx_n_s_pyx_type; -static PyObject *__pyx_n_s_pyx_unpickle_Option; -static PyObject *__pyx_n_s_pyx_vtable; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_ssh_options; -static PyObject *__pyx_n_s_str; -static PyObject *__pyx_kp_s_stringsource; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_update; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x3b84bd8, 0x59348e4, 0x80dcc6c) = (_option))"; +/* #### Code section: decls ### */ static PyObject *__pyx_pf_3ssh_7options_6Option___eq__(struct __pyx_obj_3ssh_7options_Option *__pyx_v_self, struct __pyx_obj_3ssh_7options_Option *__pyx_v_other); /* proto */ static PyObject *__pyx_pf_3ssh_7options_6Option_5value___get__(struct __pyx_obj_3ssh_7options_Option *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_3ssh_7options_6Option_2__str__(struct __pyx_obj_3ssh_7options_Option *__pyx_v_self); /* proto */ @@ -1511,13 +2309,524 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ static PyObject *__pyx_pf_3ssh_7options_6Option_8__setstate_cython__(struct __pyx_obj_3ssh_7options_Option *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_3ssh_7options___pyx_unpickle_Option(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_3ssh_7options_Option(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_int_62409688; -static PyObject *__pyx_int_93538532; -static PyObject *__pyx_int_135122028; -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_codeobj__3; -/* Late includes */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_3ssh_7options_Option; + #endif + PyTypeObject *__pyx_ptype_3ssh_7options_Option; + PyObject *__pyx_n_s_ADD_IDENTITY; + PyObject *__pyx_n_s_BINDADDR; + PyObject *__pyx_n_s_CIPHERS_C_S; + PyObject *__pyx_n_s_CIPHERS_S_C; + PyObject *__pyx_n_s_COMPRESSION; + PyObject *__pyx_n_s_COMPRESSION_C_S; + PyObject *__pyx_n_s_COMPRESSION_LEVEL; + PyObject *__pyx_n_s_COMPRESSION_S_C; + PyObject *__pyx_n_s_FD; + PyObject *__pyx_n_s_GLOBAL_KNOWNHOSTS; + PyObject *__pyx_n_s_GSSAPI_AUTH; + PyObject *__pyx_n_s_GSSAPI_CLIENT_IDENTITY; + PyObject *__pyx_n_s_GSSAPI_DELEGATE_CREDENTIALS; + PyObject *__pyx_n_s_GSSAPI_SERVER_IDENTITY; + PyObject *__pyx_n_s_HMAC_C_S; + PyObject *__pyx_n_s_HMAC_S_C; + PyObject *__pyx_n_s_HOST; + PyObject *__pyx_n_s_HOSTKEYS; + PyObject *__pyx_n_s_IDENTITY; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; + PyObject *__pyx_n_s_KBDINT_AUTH; + PyObject *__pyx_n_s_KEY_EXCHANGE; + PyObject *__pyx_n_s_KNOWNHOSTS; + PyObject *__pyx_n_s_LOG_VERBOSITY; + PyObject *__pyx_n_s_LOG_VERBOSITY_STR; + PyObject *__pyx_n_s_NODELAY; + PyObject *__pyx_n_s_Option; + PyObject *__pyx_n_s_Option___reduce_cython; + PyObject *__pyx_n_s_Option___setstate_cython; + PyObject *__pyx_n_s_PASSWORD_AUTH; + PyObject *__pyx_n_s_PORT; + PyObject *__pyx_n_s_PORT_STR; + PyObject *__pyx_n_s_PROCESS_CONFIG; + PyObject *__pyx_n_s_PROXYCOMMAND; + PyObject *__pyx_n_s_PUBKEY_AUTH; + PyObject *__pyx_n_s_PUBLICKEY_ACCEPTED_TYPES; + PyObject *__pyx_n_s_PickleError; + PyObject *__pyx_n_s_REKEY_DATA; + PyObject *__pyx_n_s_REKEY_TIME; + PyObject *__pyx_n_s_SSH1; + PyObject *__pyx_n_s_SSH2; + PyObject *__pyx_n_s_SSH_DIR; + PyObject *__pyx_n_s_STRICTHOSTKEYCHECK; + PyObject *__pyx_n_s_TIMEOUT; + PyObject *__pyx_n_s_TIMEOUT_USEC; + PyObject *__pyx_n_s_USER; + PyObject *__pyx_kp_u__2; + PyObject *__pyx_n_s__9; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_n_s_dict_2; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_new; + PyObject *__pyx_n_s_pickle; + PyObject *__pyx_n_s_pyx_PickleError; + PyObject *__pyx_n_s_pyx_checksum; + PyObject *__pyx_n_s_pyx_result; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_type; + PyObject *__pyx_n_s_pyx_unpickle_Option; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_ssh_options; + PyObject *__pyx_n_s_state; + PyObject *__pyx_n_s_str; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_update; + PyObject *__pyx_n_s_use_setstate; + PyObject *__pyx_int_62409688; + PyObject *__pyx_int_93538532; + PyObject *__pyx_int_135122028; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__5; + PyObject *__pyx_tuple__7; + PyObject *__pyx_codeobj__4; + PyObject *__pyx_codeobj__6; + PyObject *__pyx_codeobj__8; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_3ssh_7options_Option); + Py_CLEAR(clear_module_state->__pyx_type_3ssh_7options_Option); + Py_CLEAR(clear_module_state->__pyx_n_s_ADD_IDENTITY); + Py_CLEAR(clear_module_state->__pyx_n_s_BINDADDR); + Py_CLEAR(clear_module_state->__pyx_n_s_CIPHERS_C_S); + Py_CLEAR(clear_module_state->__pyx_n_s_CIPHERS_S_C); + Py_CLEAR(clear_module_state->__pyx_n_s_COMPRESSION); + Py_CLEAR(clear_module_state->__pyx_n_s_COMPRESSION_C_S); + Py_CLEAR(clear_module_state->__pyx_n_s_COMPRESSION_LEVEL); + Py_CLEAR(clear_module_state->__pyx_n_s_COMPRESSION_S_C); + Py_CLEAR(clear_module_state->__pyx_n_s_FD); + Py_CLEAR(clear_module_state->__pyx_n_s_GLOBAL_KNOWNHOSTS); + Py_CLEAR(clear_module_state->__pyx_n_s_GSSAPI_AUTH); + Py_CLEAR(clear_module_state->__pyx_n_s_GSSAPI_CLIENT_IDENTITY); + Py_CLEAR(clear_module_state->__pyx_n_s_GSSAPI_DELEGATE_CREDENTIALS); + Py_CLEAR(clear_module_state->__pyx_n_s_GSSAPI_SERVER_IDENTITY); + Py_CLEAR(clear_module_state->__pyx_n_s_HMAC_C_S); + Py_CLEAR(clear_module_state->__pyx_n_s_HMAC_S_C); + Py_CLEAR(clear_module_state->__pyx_n_s_HOST); + Py_CLEAR(clear_module_state->__pyx_n_s_HOSTKEYS); + Py_CLEAR(clear_module_state->__pyx_n_s_IDENTITY); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_CLEAR(clear_module_state->__pyx_n_s_KBDINT_AUTH); + Py_CLEAR(clear_module_state->__pyx_n_s_KEY_EXCHANGE); + Py_CLEAR(clear_module_state->__pyx_n_s_KNOWNHOSTS); + Py_CLEAR(clear_module_state->__pyx_n_s_LOG_VERBOSITY); + Py_CLEAR(clear_module_state->__pyx_n_s_LOG_VERBOSITY_STR); + Py_CLEAR(clear_module_state->__pyx_n_s_NODELAY); + Py_CLEAR(clear_module_state->__pyx_n_s_Option); + Py_CLEAR(clear_module_state->__pyx_n_s_Option___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Option___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PASSWORD_AUTH); + Py_CLEAR(clear_module_state->__pyx_n_s_PORT); + Py_CLEAR(clear_module_state->__pyx_n_s_PORT_STR); + Py_CLEAR(clear_module_state->__pyx_n_s_PROCESS_CONFIG); + Py_CLEAR(clear_module_state->__pyx_n_s_PROXYCOMMAND); + Py_CLEAR(clear_module_state->__pyx_n_s_PUBKEY_AUTH); + Py_CLEAR(clear_module_state->__pyx_n_s_PUBLICKEY_ACCEPTED_TYPES); + Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_REKEY_DATA); + Py_CLEAR(clear_module_state->__pyx_n_s_REKEY_TIME); + Py_CLEAR(clear_module_state->__pyx_n_s_SSH1); + Py_CLEAR(clear_module_state->__pyx_n_s_SSH2); + Py_CLEAR(clear_module_state->__pyx_n_s_SSH_DIR); + Py_CLEAR(clear_module_state->__pyx_n_s_STRICTHOSTKEYCHECK); + Py_CLEAR(clear_module_state->__pyx_n_s_TIMEOUT); + Py_CLEAR(clear_module_state->__pyx_n_s_TIMEOUT_USEC); + Py_CLEAR(clear_module_state->__pyx_n_s_USER); + Py_CLEAR(clear_module_state->__pyx_kp_u__2); + Py_CLEAR(clear_module_state->__pyx_n_s__9); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_new); + Py_CLEAR(clear_module_state->__pyx_n_s_pickle); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Option); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ssh_options); + Py_CLEAR(clear_module_state->__pyx_n_s_state); + Py_CLEAR(clear_module_state->__pyx_n_s_str); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_update); + Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); + Py_CLEAR(clear_module_state->__pyx_int_62409688); + Py_CLEAR(clear_module_state->__pyx_int_93538532); + Py_CLEAR(clear_module_state->__pyx_int_135122028); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__5); + Py_CLEAR(clear_module_state->__pyx_tuple__7); + Py_CLEAR(clear_module_state->__pyx_codeobj__4); + Py_CLEAR(clear_module_state->__pyx_codeobj__6); + Py_CLEAR(clear_module_state->__pyx_codeobj__8); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_3ssh_7options_Option); + Py_VISIT(traverse_module_state->__pyx_type_3ssh_7options_Option); + Py_VISIT(traverse_module_state->__pyx_n_s_ADD_IDENTITY); + Py_VISIT(traverse_module_state->__pyx_n_s_BINDADDR); + Py_VISIT(traverse_module_state->__pyx_n_s_CIPHERS_C_S); + Py_VISIT(traverse_module_state->__pyx_n_s_CIPHERS_S_C); + Py_VISIT(traverse_module_state->__pyx_n_s_COMPRESSION); + Py_VISIT(traverse_module_state->__pyx_n_s_COMPRESSION_C_S); + Py_VISIT(traverse_module_state->__pyx_n_s_COMPRESSION_LEVEL); + Py_VISIT(traverse_module_state->__pyx_n_s_COMPRESSION_S_C); + Py_VISIT(traverse_module_state->__pyx_n_s_FD); + Py_VISIT(traverse_module_state->__pyx_n_s_GLOBAL_KNOWNHOSTS); + Py_VISIT(traverse_module_state->__pyx_n_s_GSSAPI_AUTH); + Py_VISIT(traverse_module_state->__pyx_n_s_GSSAPI_CLIENT_IDENTITY); + Py_VISIT(traverse_module_state->__pyx_n_s_GSSAPI_DELEGATE_CREDENTIALS); + Py_VISIT(traverse_module_state->__pyx_n_s_GSSAPI_SERVER_IDENTITY); + Py_VISIT(traverse_module_state->__pyx_n_s_HMAC_C_S); + Py_VISIT(traverse_module_state->__pyx_n_s_HMAC_S_C); + Py_VISIT(traverse_module_state->__pyx_n_s_HOST); + Py_VISIT(traverse_module_state->__pyx_n_s_HOSTKEYS); + Py_VISIT(traverse_module_state->__pyx_n_s_IDENTITY); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_VISIT(traverse_module_state->__pyx_n_s_KBDINT_AUTH); + Py_VISIT(traverse_module_state->__pyx_n_s_KEY_EXCHANGE); + Py_VISIT(traverse_module_state->__pyx_n_s_KNOWNHOSTS); + Py_VISIT(traverse_module_state->__pyx_n_s_LOG_VERBOSITY); + Py_VISIT(traverse_module_state->__pyx_n_s_LOG_VERBOSITY_STR); + Py_VISIT(traverse_module_state->__pyx_n_s_NODELAY); + Py_VISIT(traverse_module_state->__pyx_n_s_Option); + Py_VISIT(traverse_module_state->__pyx_n_s_Option___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Option___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PASSWORD_AUTH); + Py_VISIT(traverse_module_state->__pyx_n_s_PORT); + Py_VISIT(traverse_module_state->__pyx_n_s_PORT_STR); + Py_VISIT(traverse_module_state->__pyx_n_s_PROCESS_CONFIG); + Py_VISIT(traverse_module_state->__pyx_n_s_PROXYCOMMAND); + Py_VISIT(traverse_module_state->__pyx_n_s_PUBKEY_AUTH); + Py_VISIT(traverse_module_state->__pyx_n_s_PUBLICKEY_ACCEPTED_TYPES); + Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_REKEY_DATA); + Py_VISIT(traverse_module_state->__pyx_n_s_REKEY_TIME); + Py_VISIT(traverse_module_state->__pyx_n_s_SSH1); + Py_VISIT(traverse_module_state->__pyx_n_s_SSH2); + Py_VISIT(traverse_module_state->__pyx_n_s_SSH_DIR); + Py_VISIT(traverse_module_state->__pyx_n_s_STRICTHOSTKEYCHECK); + Py_VISIT(traverse_module_state->__pyx_n_s_TIMEOUT); + Py_VISIT(traverse_module_state->__pyx_n_s_TIMEOUT_USEC); + Py_VISIT(traverse_module_state->__pyx_n_s_USER); + Py_VISIT(traverse_module_state->__pyx_kp_u__2); + Py_VISIT(traverse_module_state->__pyx_n_s__9); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_new); + Py_VISIT(traverse_module_state->__pyx_n_s_pickle); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Option); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ssh_options); + Py_VISIT(traverse_module_state->__pyx_n_s_state); + Py_VISIT(traverse_module_state->__pyx_n_s_str); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_update); + Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); + Py_VISIT(traverse_module_state->__pyx_int_62409688); + Py_VISIT(traverse_module_state->__pyx_int_93538532); + Py_VISIT(traverse_module_state->__pyx_int_135122028); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__5); + Py_VISIT(traverse_module_state->__pyx_tuple__7); + Py_VISIT(traverse_module_state->__pyx_codeobj__4); + Py_VISIT(traverse_module_state->__pyx_codeobj__6); + Py_VISIT(traverse_module_state->__pyx_codeobj__8); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_3ssh_7options_Option __pyx_mstate_global->__pyx_type_3ssh_7options_Option +#endif +#define __pyx_ptype_3ssh_7options_Option __pyx_mstate_global->__pyx_ptype_3ssh_7options_Option +#define __pyx_n_s_ADD_IDENTITY __pyx_mstate_global->__pyx_n_s_ADD_IDENTITY +#define __pyx_n_s_BINDADDR __pyx_mstate_global->__pyx_n_s_BINDADDR +#define __pyx_n_s_CIPHERS_C_S __pyx_mstate_global->__pyx_n_s_CIPHERS_C_S +#define __pyx_n_s_CIPHERS_S_C __pyx_mstate_global->__pyx_n_s_CIPHERS_S_C +#define __pyx_n_s_COMPRESSION __pyx_mstate_global->__pyx_n_s_COMPRESSION +#define __pyx_n_s_COMPRESSION_C_S __pyx_mstate_global->__pyx_n_s_COMPRESSION_C_S +#define __pyx_n_s_COMPRESSION_LEVEL __pyx_mstate_global->__pyx_n_s_COMPRESSION_LEVEL +#define __pyx_n_s_COMPRESSION_S_C __pyx_mstate_global->__pyx_n_s_COMPRESSION_S_C +#define __pyx_n_s_FD __pyx_mstate_global->__pyx_n_s_FD +#define __pyx_n_s_GLOBAL_KNOWNHOSTS __pyx_mstate_global->__pyx_n_s_GLOBAL_KNOWNHOSTS +#define __pyx_n_s_GSSAPI_AUTH __pyx_mstate_global->__pyx_n_s_GSSAPI_AUTH +#define __pyx_n_s_GSSAPI_CLIENT_IDENTITY __pyx_mstate_global->__pyx_n_s_GSSAPI_CLIENT_IDENTITY +#define __pyx_n_s_GSSAPI_DELEGATE_CREDENTIALS __pyx_mstate_global->__pyx_n_s_GSSAPI_DELEGATE_CREDENTIALS +#define __pyx_n_s_GSSAPI_SERVER_IDENTITY __pyx_mstate_global->__pyx_n_s_GSSAPI_SERVER_IDENTITY +#define __pyx_n_s_HMAC_C_S __pyx_mstate_global->__pyx_n_s_HMAC_C_S +#define __pyx_n_s_HMAC_S_C __pyx_mstate_global->__pyx_n_s_HMAC_S_C +#define __pyx_n_s_HOST __pyx_mstate_global->__pyx_n_s_HOST +#define __pyx_n_s_HOSTKEYS __pyx_mstate_global->__pyx_n_s_HOSTKEYS +#define __pyx_n_s_IDENTITY __pyx_mstate_global->__pyx_n_s_IDENTITY +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 +#define __pyx_n_s_KBDINT_AUTH __pyx_mstate_global->__pyx_n_s_KBDINT_AUTH +#define __pyx_n_s_KEY_EXCHANGE __pyx_mstate_global->__pyx_n_s_KEY_EXCHANGE +#define __pyx_n_s_KNOWNHOSTS __pyx_mstate_global->__pyx_n_s_KNOWNHOSTS +#define __pyx_n_s_LOG_VERBOSITY __pyx_mstate_global->__pyx_n_s_LOG_VERBOSITY +#define __pyx_n_s_LOG_VERBOSITY_STR __pyx_mstate_global->__pyx_n_s_LOG_VERBOSITY_STR +#define __pyx_n_s_NODELAY __pyx_mstate_global->__pyx_n_s_NODELAY +#define __pyx_n_s_Option __pyx_mstate_global->__pyx_n_s_Option +#define __pyx_n_s_Option___reduce_cython __pyx_mstate_global->__pyx_n_s_Option___reduce_cython +#define __pyx_n_s_Option___setstate_cython __pyx_mstate_global->__pyx_n_s_Option___setstate_cython +#define __pyx_n_s_PASSWORD_AUTH __pyx_mstate_global->__pyx_n_s_PASSWORD_AUTH +#define __pyx_n_s_PORT __pyx_mstate_global->__pyx_n_s_PORT +#define __pyx_n_s_PORT_STR __pyx_mstate_global->__pyx_n_s_PORT_STR +#define __pyx_n_s_PROCESS_CONFIG __pyx_mstate_global->__pyx_n_s_PROCESS_CONFIG +#define __pyx_n_s_PROXYCOMMAND __pyx_mstate_global->__pyx_n_s_PROXYCOMMAND +#define __pyx_n_s_PUBKEY_AUTH __pyx_mstate_global->__pyx_n_s_PUBKEY_AUTH +#define __pyx_n_s_PUBLICKEY_ACCEPTED_TYPES __pyx_mstate_global->__pyx_n_s_PUBLICKEY_ACCEPTED_TYPES +#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError +#define __pyx_n_s_REKEY_DATA __pyx_mstate_global->__pyx_n_s_REKEY_DATA +#define __pyx_n_s_REKEY_TIME __pyx_mstate_global->__pyx_n_s_REKEY_TIME +#define __pyx_n_s_SSH1 __pyx_mstate_global->__pyx_n_s_SSH1 +#define __pyx_n_s_SSH2 __pyx_mstate_global->__pyx_n_s_SSH2 +#define __pyx_n_s_SSH_DIR __pyx_mstate_global->__pyx_n_s_SSH_DIR +#define __pyx_n_s_STRICTHOSTKEYCHECK __pyx_mstate_global->__pyx_n_s_STRICTHOSTKEYCHECK +#define __pyx_n_s_TIMEOUT __pyx_mstate_global->__pyx_n_s_TIMEOUT +#define __pyx_n_s_TIMEOUT_USEC __pyx_mstate_global->__pyx_n_s_TIMEOUT_USEC +#define __pyx_n_s_USER __pyx_mstate_global->__pyx_n_s_USER +#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 +#define __pyx_n_s__9 __pyx_mstate_global->__pyx_n_s__9 +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new +#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle +#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError +#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum +#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type +#define __pyx_n_s_pyx_unpickle_Option __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Option +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_ssh_options __pyx_mstate_global->__pyx_n_s_ssh_options +#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state +#define __pyx_n_s_str __pyx_mstate_global->__pyx_n_s_str +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update +#define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate +#define __pyx_int_62409688 __pyx_mstate_global->__pyx_int_62409688 +#define __pyx_int_93538532 __pyx_mstate_global->__pyx_int_93538532 +#define __pyx_int_135122028 __pyx_mstate_global->__pyx_int_135122028 +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 +#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 +#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 +#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 +#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8 +/* #### Code section: module_code ### */ /* "ssh/options.pyx":24 * @@ -1535,7 +2844,7 @@ static struct __pyx_obj_3ssh_7options_Option *__pyx_f_3ssh_7options_6Option_from int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("from_option", 0); + __Pyx_RefNannySetupContext("from_option", 1); /* "ssh/options.pyx":25 * @staticmethod @@ -1545,7 +2854,7 @@ static struct __pyx_obj_3ssh_7options_Option *__pyx_f_3ssh_7options_6Option_from * return _option */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_3ssh_7options_Option(((PyTypeObject *)__pyx_ptype_3ssh_7options_Option), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(((PyObject *)__pyx_t_1)); + __Pyx_GOTREF((PyObject *)__pyx_t_1); __pyx_v__option = ((struct __pyx_obj_3ssh_7options_Option *)__pyx_t_1); __pyx_t_1 = 0; @@ -1565,8 +2874,8 @@ static struct __pyx_obj_3ssh_7options_Option *__pyx_f_3ssh_7options_6Option_from * * def __eq__(self, Option other): */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v__option)); + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__option); __pyx_r = __pyx_v__option; goto __pyx_L0; @@ -1601,12 +2910,14 @@ static struct __pyx_obj_3ssh_7options_Option *__pyx_f_3ssh_7options_6Option_from /* Python wrapper */ static PyObject *__pyx_pw_3ssh_7options_6Option_1__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ static PyObject *__pyx_pw_3ssh_7options_6Option_1__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_other), __pyx_ptype_3ssh_7options_Option, 1, "other", 0))) __PYX_ERR(0, 29, __pyx_L1_error) __pyx_r = __pyx_pf_3ssh_7options_6Option___eq__(((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_self), ((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_other)); @@ -1626,7 +2937,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option___eq__(struct __pyx_obj_3ssh_7op int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_RefNannySetupContext("__eq__", 1); /* "ssh/options.pyx":30 * @@ -1661,20 +2972,22 @@ static PyObject *__pyx_pf_3ssh_7options_6Option___eq__(struct __pyx_obj_3ssh_7op return __pyx_r; } -/* "ssh/options.pyx":33 +/* "ssh/options.pyx":32 + * return self._option == other._option * - * @property - * def value(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def value(self): * return self._option - * */ /* Python wrapper */ static PyObject *__pyx_pw_3ssh_7options_6Option_5value_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_7options_6Option_5value_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_3ssh_7options_6Option_5value___get__(((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_self)); /* function exit code */ @@ -1689,7 +3002,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_5value___get__(struct __pyx_obj_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "ssh/options.pyx":34 * @property @@ -1705,12 +3018,12 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_5value___get__(struct __pyx_obj_ __pyx_t_1 = 0; goto __pyx_L0; - /* "ssh/options.pyx":33 + /* "ssh/options.pyx":32 + * return self._option == other._option * - * @property - * def value(self): # <<<<<<<<<<<<<< + * @property # <<<<<<<<<<<<<< + * def value(self): * return self._option - * */ /* function exit code */ @@ -1735,9 +3048,11 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_5value___get__(struct __pyx_obj_ /* Python wrapper */ static PyObject *__pyx_pw_3ssh_7options_6Option_3__str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_7options_6Option_3__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_3ssh_7options_6Option_2__str__(((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_self)); /* function exit code */ @@ -1753,7 +3068,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_2__str__(struct __pyx_obj_3ssh_7 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 0); + __Pyx_RefNannySetupContext("__str__", 1); /* "ssh/options.pyx":37 * @@ -1765,7 +3080,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_2__str__(struct __pyx_obj_3ssh_7 __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_enum__ssh_options_e(__pyx_v_self->_option); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; @@ -1803,9 +3118,11 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_2__str__(struct __pyx_obj_3ssh_7 /* Python wrapper */ static PyObject *__pyx_pw_3ssh_7options_6Option_5__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_3ssh_7options_6Option_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_3ssh_7options_6Option_4__repr__(((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_self)); /* function exit code */ @@ -1819,10 +3136,11 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_4__repr__(struct __pyx_obj_3ssh_ PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_RefNannySetupContext("__repr__", 1); /* "ssh/options.pyx":40 * @@ -1835,20 +3153,27 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_4__repr__(struct __pyx_obj_3ssh_ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; } } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -1881,12 +3206,40 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_4__repr__(struct __pyx_obj_3ssh_ */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7options_6Option_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_3ssh_7options_6Option_6__reduce_cython__[] = "Option.__reduce_cython__(self)"; -static PyObject *__pyx_pw_3ssh_7options_6Option_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_3ssh_7options_6Option_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7options_6Option_6__reduce_cython__, "Option.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_3ssh_7options_6Option_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7options_6Option_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7options_6Option_6__reduce_cython__}; +static PyObject *__pyx_pw_3ssh_7options_6Option_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_3ssh_7options_6Option_6__reduce_cython__(((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_self)); /* function exit code */ @@ -1903,12 +3256,11 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":5 * cdef object _dict @@ -1922,7 +3274,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error); __pyx_t_1 = 0; __pyx_v_state = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; @@ -1947,8 +3299,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ * use_setstate = True */ __pyx_t_3 = (__pyx_v__dict != Py_None); - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + if (__pyx_t_3) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -1961,7 +3312,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -1992,7 +3343,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ * else: * use_setstate = False # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, None), state + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, None), state */ /*else*/ { __pyx_v_use_setstate = 0; @@ -2003,18 +3354,17 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, None), state + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, None), state * else: */ - __pyx_t_4 = (__pyx_v_use_setstate != 0); - if (__pyx_t_4) { + if (__pyx_v_use_setstate) { /* "(tree fragment)":13 * use_setstate = False * if use_setstate: - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, state) + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pyx_unpickle_Option); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) @@ -2023,66 +3373,66 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_135122028); - __Pyx_GIVEREF(__pyx_int_135122028); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_135122028); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_62409688); + __Pyx_GIVEREF(__pyx_int_62409688); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_62409688)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_2 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, None), state + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, None), state + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, None), state * else: - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Option__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Option); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Option); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_135122028); - __Pyx_GIVEREF(__pyx_int_135122028); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_135122028); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_62409688); + __Pyx_GIVEREF(__pyx_int_62409688); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_62409688)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); - __pyx_t_5 = 0; + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -2099,7 +3449,7 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("ssh.options.Option.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -2112,21 +3462,104 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_6__reduce_cython__(struct __pyx_ /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, state) + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Option__set_state(self, __pyx_state) */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7options_6Option_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static char __pyx_doc_3ssh_7options_6Option_8__setstate_cython__[] = "Option.__setstate_cython__(self, __pyx_state)"; -static PyObject *__pyx_pw_3ssh_7options_6Option_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_3ssh_7options_6Option_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7options_6Option_8__setstate_cython__, "Option.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_7options_6Option_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7options_6Option_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7options_6Option_8__setstate_cython__}; +static PyObject *__pyx_pw_3ssh_7options_6Option_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_3ssh_7options_6Option_8__setstate_cython__(((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("ssh.options.Option.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3ssh_7options_6Option_8__setstate_cython__(((struct __pyx_obj_3ssh_7options_Option *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2138,21 +3571,21 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_8__setstate_cython__(struct __py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":17 - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, state) + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Option__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_3ssh_7options___pyx_unpickle_Option__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: - * return __pyx_unpickle_Option, (type(self), 0x80dcc6c, state) + * return __pyx_unpickle_Option, (type(self), 0x3b84bd8, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Option__set_state(self, __pyx_state) */ @@ -2177,71 +3610,115 @@ static PyObject *__pyx_pf_3ssh_7options_6Option_8__setstate_cython__(struct __py */ /* Python wrapper */ -static PyObject *__pyx_pw_3ssh_7options_1__pyx_unpickle_Option(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_3ssh_7options___pyx_unpickle_Option[] = "__pyx_unpickle_Option(__pyx_type, long __pyx_checksum, __pyx_state)"; -static PyMethodDef __pyx_mdef_3ssh_7options_1__pyx_unpickle_Option = {"__pyx_unpickle_Option", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3ssh_7options_1__pyx_unpickle_Option, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3ssh_7options___pyx_unpickle_Option}; -static PyObject *__pyx_pw_3ssh_7options_1__pyx_unpickle_Option(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_3ssh_7options_1__pyx_unpickle_Option(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_3ssh_7options___pyx_unpickle_Option, "__pyx_unpickle_Option(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_3ssh_7options_1__pyx_unpickle_Option = {"__pyx_unpickle_Option", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_3ssh_7options_1__pyx_unpickle_Option, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_3ssh_7options___pyx_unpickle_Option}; +static PyObject *__pyx_pw_3ssh_7options_1__pyx_unpickle_Option(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_Option (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Option", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Option", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Option") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Option") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Option", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Option", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("ssh.options.__pyx_unpickle_Option", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -2249,6 +3726,12 @@ static PyObject *__pyx_pw_3ssh_7options_1__pyx_unpickle_Option(PyObject *__pyx_s __pyx_r = __pyx_pf_3ssh_7options___pyx_unpickle_Option(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2260,129 +3743,116 @@ static PyObject *__pyx_pf_3ssh_7options___pyx_unpickle_Option(CYTHON_UNUSED PyOb __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; + int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Option", 0); + __Pyx_RefNannySetupContext("__pyx_unpickle_Option", 1); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum not in (0x80dcc6c, 0x3b84bd8, 0x59348e4): # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0x3b84bd8, 0x59348e4, 0x80dcc6c): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x80dcc6c, 0x3b84bd8, 0x59348e4) = (_option))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3b84bd8, 0x59348e4, 0x80dcc6c) = (_option))" % __pyx_checksum */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple_, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple_, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { /* "(tree fragment)":5 * cdef object __pyx_result - * if __pyx_checksum not in (0x80dcc6c, 0x3b84bd8, 0x59348e4): + * if __pyx_checksum not in (0x3b84bd8, 0x59348e4, 0x80dcc6c): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x80dcc6c, 0x3b84bd8, 0x59348e4) = (_option))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3b84bd8, 0x59348e4, 0x80dcc6c) = (_option))" % __pyx_checksum * __pyx_result = Option.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); - __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 - * if __pyx_checksum not in (0x80dcc6c, 0x3b84bd8, 0x59348e4): + * if __pyx_checksum not in (0x3b84bd8, 0x59348e4, 0x80dcc6c): * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x80dcc6c, 0x3b84bd8, 0x59348e4) = (_option))" % __pyx_checksum) # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3b84bd8, 0x59348e4, 0x80dcc6c) = (_option))" % __pyx_checksum # <<<<<<<<<<<<<< * __pyx_result = Option.__new__(__pyx_type) * if __pyx_state is not None: */ - __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum not in (0x80dcc6c, 0x3b84bd8, 0x59348e4): # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0x3b84bd8, 0x59348e4, 0x80dcc6c): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x80dcc6c, 0x3b84bd8, 0x59348e4) = (_option))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3b84bd8, 0x59348e4, 0x80dcc6c) = (_option))" % __pyx_checksum */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x80dcc6c, 0x3b84bd8, 0x59348e4) = (_option))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3b84bd8, 0x59348e4, 0x80dcc6c) = (_option))" % __pyx_checksum * __pyx_result = Option.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_Option__set_state(