pax_global_header00006660000000000000000000000064146527351720014526gustar00rootroot0000000000000052 comment=91d17815b911ccc2c1d1408412e7885c32f2d460 pyliblo3-master/000077500000000000000000000000001465273517200141205ustar00rootroot00000000000000pyliblo3-master/.github/000077500000000000000000000000001465273517200154605ustar00rootroot00000000000000pyliblo3-master/.github/workflows/000077500000000000000000000000001465273517200175155ustar00rootroot00000000000000pyliblo3-master/.github/workflows/test.yml000066400000000000000000000015461465273517200212250ustar00rootroot00000000000000name: Test on: [push] jobs: alltest: runs-on: ${{ matrix.os }} strategy: matrix: os: [ "windows-latest", "ubuntu-latest", "macos-latest" ] python-version: [ "3.10", "3.12" ] # Test extremes only install-method: [ # "git", "pip" ] fail-fast: false steps: - uses: actions/checkout@v3 - uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - name: check macos arch if: ${{ runner.os }} == macos run: | uname -m - name: install from pip if: ${{ matrix.install-method == 'pip' }} run: | pip install --verbose "pyliblo3>=0.16" - name: run unittests run: | cd test python unit.py pyliblo3-master/.github/workflows/wheels.yml000066400000000000000000000065601465273517200215360ustar00rootroot00000000000000name: Build on: [push, pull_request] # on: create jobs: build_wheels: name: Build python wheels on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: matrix: os: [ macos-12, windows-latest, ubuntu-latest ] steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v3 - name: Install cibuildwheel run: python -m pip install cibuildwheel - name: Windows - Enable Developer Command Prompt uses: ilammy/msvc-dev-cmd@v1.7.0 - name: macos dependencies if: runner.os == 'macos' run: | python -m pip install delocate # brew install liblo git clone https://github.com/radarsat1/liblo cd liblo mkdir macosbuild cd macosbuild cmake -DCMAKE_OSX_DEPLOYMENT_TARGET=11 -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64" ../cmake cmake --build . --config Release sudo cmake --install . file /usr/local/lib/liblo.dylib - name: Install dependencies windows if: runner.os == 'windows' run: | git clone https://github.com/radarsat1/liblo cd liblo New-Item -ItemType Directory -Force -Path "windowsbuild" cd windowsbuild cmake -A x64 -DCMAKE_GENERATOR_PLATFORM=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_TESTS=OFF -DWITH_CPP_TESTS=OFF -DWITH_EXAMPLES=OFF -DWITH_TOOLS=OFF ../cmake cmake --build . --config Release Get-ChildItem -Recurse cmake --install . - name: Build wheels run: python -m cibuildwheel --output-dir wheelhouse # to supply options, put them in 'env', like: env: MACOSX_DEPLOYMENT_TARGET: 11 CIBW_BUILD_VERBOSITY: 1 CIBW_BUILD: 'cp310-* cp311-* cp312-*' CIBW_ARCHS_MACOS: 'arm64' CIBW_ARCHS_WINDOWS: AMD64 CIBW_SKIP: 'pp* *686* *-musllinux_*' # CIBW_BEFORE_ALL_LINUX: yum search liblo; yum install -y liblo-devel CIBW_BEFORE_ALL_LINUX: git clone https://github.com/radarsat1/liblo; cd liblo; mkdir linuxbuild; cd linuxbuild; cmake ../cmake; cmake --build .; cmake --install . # CIBW_BEFORE_ALL_MACOS: brew install liblo CIBW_REPAIR_WHEEL_COMMAND_MACOS: delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel} --require-target-macos-version 11 # Use delvewheel on windows CIBW_BEFORE_BUILD_WINDOWS: "pip install delvewheel" CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: 'delvewheel repair --add-path "C:/Program Files/liblo/lib;C:/Program Files/liblo/bin" -w {dest_dir} {wheel}' - name: Check wheels if: runner.os == 'macos' run: | delocate-listdeps --all wheelhouse/*.whl # CIBW_SOME_OPTION: value - uses: actions/upload-artifact@v4 with: name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }} path: ./wheelhouse/*.whl - name: Upload wheels env: TWINE_USERNAME: __token__ TWINE_PASSWORD: ${{ secrets.TWINETOKEN }} run: | echo $TWINE_USERNAME echo $TWINE_PASSWORD python -m pip install -U twine virtualenv twine upload --skip-existing wheelhouse/*.whl continue-on-error: true pyliblo3-master/.gitignore000077500000000000000000000001721465273517200161130ustar00rootroot00000000000000site/ *.egg* build/ dist/ *.o *.lo *.la *.cache *.pyc *.bak *.so *.whl .deps .idea .mypy* src/liblo.c wheelhouse/ *.kate* pyliblo3-master/COPYING000077500000000000000000000635041465273517200151660ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! pyliblo3-master/MANIFEST.in000066400000000000000000000001161465273517200156540ustar00rootroot00000000000000recursive-include pyliblo3 *.py *.pyx *.pxd *.pyi recursive-include scripts * pyliblo3-master/NEWS000077500000000000000000000073401465273517200146260ustar00rootroot000000000000002024: pyliblo3 can build binary wheels for all platforms * Including native wheels for macos arm64 * All dependencies (the liblo library itself) are included within the wheels 2020: pyliblo3 can build manylinux wheels 2019: pyliblo3 is forked from pylibo * Add the possibility to delete previous registered /methods * Modernize the setup.py to make it pip installable 2011-01-29: pyliblo 0.9.1 * Changed send functions to raise an IOError if sending failed (probaby most useful with TCP connections). * Lots of code cleanup and deobfuscation. * Included unit tests in release tarball. 2010-10-22: pyliblo 0.9.0 * Support Python 3.x. As a result, pyliblo can no longer be built with Pyrex, and requires Cython >= 0.12 instead. * Added free() method to Server and ServerThread classes. * Added fileno() method to Server and ServerThread classes (thanks to Edward George). * Prefer read-only properties over getter methods (which still exist, but are now deprecated). * Added proper docstrings (copied from the HTML docs). * The minimum version of liblo required by pyliblo is now 0.26. 2009-11-30: pyliblo 0.8.1 * Release the Python GIL inside Server.recv(). * Fixed a possible segfault when the error handler was called from the * liblo server thread. 2009-09-13: pyliblo 0.8.0 * Changed license from GPL 2 to LGPL 2.1 (as did liblo in version 0.26). * Added protocol parameter to the Server class. Among other things, this allows TCP connections. * The minumum version of liblo required by pyliblo is now 0.24. * pyliblo can now be built with either Pyrex or Cython. 2009-01-19: pyliblo 0.7.2 * Fixed all compiler warnings properly in Pyrex, without patching the generated C code. * Return values of callback functions are no longer ignored, but handled as in liblo. * The send_osc script can now be run with an explicit type string, instead of trying to determine the argument types automatically. 2008-08-03: pyliblo 0.7.1 * Added manpages for send_osc and dump_osc. 2008-03-03: pyliblo 0.7.0 * Fixed memory leaks, caused by failure to free() the result of lo_server_get_url() and lo_address_get_url(). * Added parameter to Server.register_methods() to allow registering functions of an object other than the server itself. * Allow callback functions to have a variable number of arguments (*args). 2007-12-14: pyliblo 0.6.4 * Avoid creating circular references when using methods as callback functions, which in some cases prevented the server object from being deleted properly. 2007-08-10: pyliblo 0.6.3 * Patched the Pyrex-generated code to make it compile without warnings. * Always build from the existing C source by default. 2007-07-29: pyliblo 0.6.2 * Minor code cleanup, hopefully not breaking anything. * Somewhat faster conversion of blob data from and to Python lists. 2007-07-07: pyliblo 0.6.1 * Fixed a bug that caused the floats 0.0 and 1.0 to be sent as boolean. Thanks to Jesse Chappell for the patch. 2007-05-20: pyliblo 0.6 * Added support for sending bundles, optionally with timestamps. * Added previously unsupported OSC data types (timetag, midi, symbol, true/false/nil/infinitum). * New @make_method decorator. * Various bugfixes. 2007-04-28: pyliblo 0.5.1 * Fixed a stupid typo in Server.send(). 2007-04-26: pyliblo 0.5 * Simplified the way arguments are passed to callback functions. For the server side, this release is therefore incompatible with previous versions! * Some more cleanup. 2007-04-02: pyliblo 0.3 * Added class ServerThread for asynchronous dispatching of incoming messages. 2007-04-01: pyliblo 0.2 * Minor improvements. 2007-02-20: pyliblo 0.1 * Initial release. pyliblo3-master/PKG-INFO000077500000000000000000000005061465273517200152210ustar00rootroot00000000000000Metadata-Version: 1.0 Name: pyliblo3 Version: 0.16.1 Summary: fork of pyliblo (http://das.nasophon.de/pyliblo/) Home-page: https://github.com/gesellkammer/pyliblo3 Author: Dominic Sacre Author-email: dominic.sacre@gmx.de Maintainer: Eduardo Moguillansky Maintainer-email: License: LGPL Description: UNKNOWN Platform: UNKNOWN pyliblo3-master/README.md000077500000000000000000000046431465273517200154110ustar00rootroot00000000000000# pyliblo3 This is a fork of the original bindings for liblo, making it pip installable. The provided wheels include the ``liblo`` library and don't have any further dependencies, making it completely pip installable ## Example ### Simple blocking server ```python import pyliblo3 as liblo server = liblo.Server(8080) def test_handler(path, args, types, src): print(args) server.add_method("/test", None, test_handler) while True: server.recv(100) ``` ### Threaded server ```python from pyliblo3 import * import time class MyServer(ServerThread): def __init__(self, port=1234): ServerThread.__init__(self, port) @make_method('/foo', 'ifs') def foo_callback(self, path, args): i, f, s = args print(f"Received message '{path}' with arguments: {i=}, {f=}, {s=}") @make_method(None, None) def fallback(self, path, args): print(f"received unknown message '{path}' with {args=}") server = MyServer() server.start() print(f"Server started in its own thread, send messages to {server.port}. Use CTRL-C to stop") while True: send(("127.0.0.0", server.port), "/foo", 10, 1.5, "bar") send(("127.0.0.0", server.port), "/unknown", (3, 4)) time.sleep(1) ``` ---------------------- ## Documentation https://pyliblo3.readthedocs.io ----------------------- ## Installation ```bash pip install pyliblo3 ``` ## Installation from source When installing from source, ``liblo`` needs to be installed. #### Linux ```bash sudo apt install liblo-dev git clone https://github.com/gesellkammer/pyliblo3 cd pyliblo3 pip install . ``` #### MacOS First install liblo ```bash brew install liblo ``` Or, without using brew: ```bash git clone https://github.com/radarsat1/liblo cd liblo mkdir macosbuild && cd macosbuild cmake -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64" ../cmake cmake --build . --config Release sudo cmake --install . ``` Then install pyliblo3 ```bash git clone https://github.com/gesellkammer/pyliblo3 cd pyliblo3 pip install . ``` #### Windows ```bash git clone https://github.com/radarsat1/liblo cd liblo New-Item -ItemType Directory -Force -Path "windowsbuild" cd windowsbuild cmake -A x64 -DCMAKE_GENERATOR_PLATFORM=x64 -DWITH_TESTS=OFF -DWITH_CPP_TESTS=OFF -DWITH_EXAMPLES=OFF -DWITH_TOOLS=OFF ../cmake cmake --build . --config Release cmake --install . ``` ```bash git clone https://github.com/gesellkammer/pyliblo3 cd pyliblo3 pip install . ``` pyliblo3-master/doc/000077500000000000000000000000001465273517200146655ustar00rootroot00000000000000pyliblo3-master/doc/Makefile000066400000000000000000000003621465273517200163260ustar00rootroot00000000000000SPHINXOPTS = SPHINXBUILD = sphinx-build BUILDDIR = build ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(SPHINXOPTS) . .PHONY: clean html html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html clean: -rm -rf $(BUILDDIR)/* pyliblo3-master/doc/conf.py000066400000000000000000000044671465273517200161770ustar00rootroot00000000000000# -*- coding: utf-8 -*- # import sys, os sys.path.insert(0, os.path.abspath('..')) #extensions = ['sphinx.ext.autodoc', 'sphinxcontrib.fulltoc'] extensions = ['sphinx.ext.autodoc'] templates_path = ['templates'] html_theme_path = ['theme'] exclude_patterns = ['build'] source_suffix = '.rst' master_doc = 'index' project = u'pyliblo' copyright = u'2007-2014, Dominic Sacré' version = '0.10.0' release = '' html_theme = 'nasophon' html_copy_source = False pygments_style = 'sphinx' add_module_names = False autodoc_member_order = 'bysource' autodoc_default_flags = ['members', 'undoc-members'] from sphinx.ext.autodoc import py_ext_sig_re from sphinx.util.docstrings import prepare_docstring from sphinx.domains.python import PyClassmember, PyObject, py_sig_re def process_docstring(app, what, name, obj, options, lines): """ Remove leading function signatures from docstring. """ while len(lines) and py_ext_sig_re.match(lines[0]) is not None: del lines[0] def process_signature(app, what, name, obj, options, signature, return_annotation): """ Replace function signature with those specified in the docstring. """ if hasattr(obj, '__doc__') and obj.__doc__ is not None: lines = prepare_docstring(obj.__doc__) siglines = [] for line in lines: if py_ext_sig_re.match(line) is not None: siglines.append(line) else: break if len(siglines): siglines[0] = siglines[0][siglines[0].index('('):] return ('\n'.join(siglines), None) return (signature, return_annotation) # monkey-patch PyClassmember.handle_signature() to replace __init__ # with the class name. handle_signature_orig = PyClassmember.handle_signature def handle_signature(self, sig, signode): if '__init__' in sig: m = py_sig_re.match(sig) name_prefix, name, arglist, retann = m.groups() sig = sig.replace('__init__', name_prefix[:-1]) return handle_signature_orig(self, sig, signode) PyClassmember.handle_signature = handle_signature # prevent exception fields from collapsing PyObject.doc_field_types[2].can_collapse = False def setup(app): app.connect('autodoc-process-docstring', process_docstring) app.connect('autodoc-process-signature', process_signature) pyliblo3-master/doc/index.rst000066400000000000000000000057361465273517200165410ustar00rootroot00000000000000.. module:: liblo ############################## pyliblo 0.10 API Documentation ############################## Homepage: http://das.nasophon.de/pyliblo/ The latest version of this manual can be found at http://dsacre.github.io/pyliblo/doc/. For the most part, pyliblo is just a thin wrapper around `liblo `_, which does all the real work. For questions not answered here, also see the `liblo documentation `_ and the `OSC spec `_. Module-level Functions ====================== .. autofunction:: send .. autofunction:: time OSC Server Classes ================== .. autoclass:: Server :no-members: .. automethod:: __init__ .. automethod:: recv .. automethod:: send .. automethod:: add_method .. automethod:: del_method .. automethod:: register_methods .. automethod:: add_bundle_handlers .. autoattribute:: url .. autoattribute:: port .. autoattribute:: protocol .. automethod:: fileno .. automethod:: free ------- .. autoclass:: ServerThread :no-members: .. automethod:: __init__ .. automethod:: start .. automethod:: stop .. autoclass:: make_method .. automethod:: __init__ Utility Classes =============== .. autoclass:: Address :no-members: .. automethod:: __init__ .. autoattribute:: url .. autoattribute:: hostname .. autoattribute:: port .. autoattribute:: protocol ------- .. autoclass:: Message .. automethod:: __init__ .. autoclass:: Bundle .. automethod:: __init__ ------- .. autoexception:: ServerError .. autoexception:: AddressError Mapping between OSC and Python data types ========================================= When constructing a message, pyliblo automatically converts arguments to an appropriate OSC data type. To explicitly specify the OSC data type to be transmitted, pass a ``(typetag, data)`` tuple instead. Some types can't be unambiguously recognized, so they can only be sent that way. The mapping between OSC and Python data types is shown in the following table: ========= =============== ==================================================== typetag OSC data type Python data type ========= =============== ==================================================== ``'i'`` int32 :class:`int` ``'h'`` int64 :class:`long` (Python 2.x), :class:`int` (Python 3.x) ``'f'`` float :class:`float` ``'d'`` double :class:`float` ``'c'`` char :class:`str` (single character) ``'s'`` string :class:`str` ``'S'`` symbol :class:`str` ``'m'`` midi :class:`tuple` of four :class:`int`\ s ``'t'`` timetag :class:`float` ``'T'`` true ``'F'`` false ``'N'`` nil ``'I'`` infinitum ``'b'`` blob :class:`list` of :class:`int`\ s (Python 2.x), :class:`bytes` (Python 3.x) ========= =============== ==================================================== pyliblo3-master/doc/theme/000077500000000000000000000000001465273517200157675ustar00rootroot00000000000000pyliblo3-master/doc/theme/nasophon/000077500000000000000000000000001465273517200176145ustar00rootroot00000000000000pyliblo3-master/doc/theme/nasophon/static/000077500000000000000000000000001465273517200211035ustar00rootroot00000000000000pyliblo3-master/doc/theme/nasophon/static/nasophon.css000066400000000000000000000074421465273517200234510ustar00rootroot00000000000000@import url("default.css"); body { background-color: white; margin-left: 1em; margin-right: 1em; width: 68em; margin: 0 auto; font-size: 95%; } div.related { margin-bottom: 1.2em; padding: 0.5em 0; border-top: 1px solid #ccc; margin-top: 0.5em; } div.related:first-child { border-top: 0; border-bottom: 1px solid #ccc; } div.sphinxsidebar { background-color: #f4f4f4; border-radius: 5px; line-height: 110%; } div.sphinxsidebar ul, div.sphinxsidebar ul ul { list-style: none; } div.sphinxsidebar li { margin-bottom: 0.5em; } div.sphinxsidebar li > ul { margin-top: 0.5em; } div.sphinxsidebar h3, div.sphinxsidebar h4 { margin-top: 1.5em; } div.sphinxsidebarwrapper > h3:first-child { margin-top: 0.2em; } div.sphinxsidebarwrapper { padding: 10px 10px 0px 10px; } div.sphinxsidebarwrapper > ul { margin-left: 0px; margin-right: 0px; } div.sphinxsidebar li.current { background: #fff; width: auto; border-radius: 3px; padding-bottom: 1px; } div.sphinxsidebar a.current { font-weight: bold; color: #fff; background: #52576a; border: 3px solid #52576a; border-radius: 3px; width: auto; display: block; } div.sphinxsidebar input { font-family: 'Lucida Grande',Arial,sans-serif; border: 1px solid #999999; font-size: smaller; border-radius: 3px; } div.sphinxsidebar input[type=text] { max-width: 150px; } div.body { padding: 0 0.6em 0 2.2em; } div.body p { line-height: 140%; } div.body h1 { margin: 0 -0.4em 0 -0.6em; border: 0; color: #ffffff; background: #52576a; border-radius: 5px; font-size: 150%; } div.body h1 a, div.body h1 a:visited { color: #ffffff; } div.body h2 { margin: 1.5em -0.45em 0 -0.65em; border: 0; color: #111111; background: #eeeeee; border-radius: 5px; font-size: 135%; } div.body h3 { font-weight: bold; color: #444; border: 0; font-size: 105%; padding-left: 1.25em; margin-right: 0em; padding-bottom: 0em; margin-bottom: 0em; } div.body hr { border: 0; background-color: #ccc; height: 1px; } div.body pre { border-radius: 3px; border: 1px solid #ac9; } div.body div.admonition, div.body div.impl-detail { border-radius: 3px; } div.body div.impl-detail > p { margin: 0; } div.body div.seealso { border: 1px solid #dddd66; } div.body div.note { background-color: #ffc; border: 1px solid #dd6; } div.body div.note tt { background: transparent; } div.body a { color: #127; } div.body a:visited { color: #127; } tt, pre { font-family: monospace, sans-serif; font-size: 93%; } div.body tt { border-radius: 3px; } div.body tt.descname { font-size: 100%; } div.body tt.xref, div.body a tt { } .deprecated { border-radius: 3px; } table.docutils { border: 1px solid #ddd; min-width: 20%; border-radius: 3px; margin-top: 10px; margin-bottom: 10px; } table.docutils td, table.docutils th { border: 1px solid #ddd !important; border-radius: 3px; } table p, table li { text-align: left !important; } table.docutils th { background-color: #eee; padding: 0.3em 0.5em; } table.docutils td { background-color: white; padding: 0.3em 0.5em; } table.footnote, table.footnote td { border: 0 !important; } div.footer { line-height: 150%; margin-top: -2em; text-align: right; width: auto; margin-right: 10px; } /* fix space below last line in multi-line table cells */ td .line-block { margin-bottom: 0; } /* No line break before first line of parameter description */ td.field-body strong+p { display: inline; } /* No blank lines within parameter lists */ dd, dl { margin-bottom: 0px; } a.headerlink { float: right; } pyliblo3-master/doc/theme/nasophon/theme.conf000066400000000000000000000007631465273517200215730ustar00rootroot00000000000000[theme] inherit = default stylesheet = nasophon.css pygments_style = sphinx [options] bodyfont = 'Lucida Grande', Arial, sans-serif headfont = 'Lucida Grande', Arial, sans-serif footerbgcolor = white footertextcolor = #555 relbarbgcolor = #fff relbartextcolor = #666 relbarlinkcolor = #444 sidebarbgcolor = white sidebartextcolor = #111 sidebarlinkcolor = #111 bgcolor = white textcolor = #222 linkcolor = #127 visitedlinkcolor = #0127 headtextcolor = #111 headbgcolor = white headlinkcolor = #aaa pyliblo3-master/doc/theme/pydoctheme/000077500000000000000000000000001465273517200201305ustar00rootroot00000000000000pyliblo3-master/doc/theme/pydoctheme/static/000077500000000000000000000000001465273517200214175ustar00rootroot00000000000000pyliblo3-master/doc/theme/pydoctheme/static/pydoctheme.css000066400000000000000000000051451465273517200242770ustar00rootroot00000000000000@import url("default.css"); body { background-color: white; margin-left: 1em; margin-right: 1em; } div.related { margin-bottom: 1.2em; padding: 0.5em 0; border-top: 1px solid #ccc; margin-top: 0.5em; } div.related a:hover { color: #0095C4; } div.related:first-child { border-top: 0; border-bottom: 1px solid #ccc; } div.sphinxsidebar { background-color: #eeeeee; border-radius: 5px; line-height: 130%; font-size: smaller; } div.sphinxsidebar h3, div.sphinxsidebar h4 { margin-top: 1.5em; } div.sphinxsidebarwrapper > h3:first-child { margin-top: 0.2em; } div.sphinxsidebarwrapper > ul > li > ul > li { margin-bottom: 0.4em; } div.sphinxsidebar a:hover { color: #0095C4; } div.sphinxsidebar input { font-family: 'Lucida Grande',Arial,sans-serif; border: 1px solid #999999; font-size: smaller; border-radius: 3px; } div.sphinxsidebar input[type=text] { max-width: 150px; } div.body { padding: 0 0 0 1.2em; } div.body p { line-height: 140%; } div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { margin: 0; border: 0; padding: 0.3em 0; } div.body hr { border: 0; background-color: #ccc; height: 1px; } div.body pre { border-radius: 3px; border: 1px solid #ac9; } div.body div.admonition, div.body div.impl-detail { border-radius: 3px; } div.body div.impl-detail > p { margin: 0; } div.body div.seealso { border: 1px solid #dddd66; } div.body a { color: #00608f; } div.body a:visited { color: #30306f; } div.body a:hover { color: #00B0E4; } tt, pre { font-family: monospace, sans-serif; font-size: 96.5%; } div.body tt { border-radius: 3px; } div.body tt.descname { font-size: 120%; } div.body tt.xref, div.body a tt { font-weight: normal; } .deprecated { border-radius: 3px; } table.docutils { border: 1px solid #ddd; min-width: 20%; border-radius: 3px; margin-top: 10px; margin-bottom: 10px; } table.docutils td, table.docutils th { border: 1px solid #ddd !important; border-radius: 3px; } table p, table li { text-align: left !important; } table.docutils th { background-color: #eee; padding: 0.3em 0.5em; } table.docutils td { background-color: white; padding: 0.3em 0.5em; } table.footnote, table.footnote td { border: 0 !important; } div.footer { line-height: 150%; margin-top: -2em; text-align: right; width: auto; margin-right: 10px; } div.footer a:hover { color: #0095C4; } .refcount { color: #060; } .stableabi { color: #229; } pyliblo3-master/doc/theme/pydoctheme/theme.conf000066400000000000000000000010231465273517200220750ustar00rootroot00000000000000[theme] inherit = default stylesheet = pydoctheme.css pygments_style = sphinx [options] bodyfont = 'Lucida Grande', Arial, sans-serif headfont = 'Lucida Grande', Arial, sans-serif footerbgcolor = white footertextcolor = #555555 relbarbgcolor = white relbartextcolor = #666666 relbarlinkcolor = #444444 sidebarbgcolor = white sidebartextcolor = #444444 sidebarlinkcolor = #444444 bgcolor = white textcolor = #222222 linkcolor = #0090c0 visitedlinkcolor = #00608f headtextcolor = #1a1a1a headbgcolor = white headlinkcolor = #aaaaaa pyliblo3-master/docs/000077500000000000000000000000001465273517200150505ustar00rootroot00000000000000pyliblo3-master/docs/Reference.md000066400000000000000000000404731465273517200173000ustar00rootroot00000000000000# Reference --------- | Class | Description | | :---- | :----------- | | [Address](#address) | Address(addr, addr2=None, proto=LO_UDP) | | [AddressError](#addresserror) | Raised when trying to create an invalid `Address` object. | | [Bundle](#bundle) | Bundle(*messages) | | [Callback](#callback) | Callback(func, user_data) | | [Message](#message) | Message(path, *args) | | [Server](#server) | Server(port=None, proto=LO_DEFAULT, reg_methods=True) | | [ServerError](#servererror) | Raised when creating a liblo OSC server fails. | | [ServerThread](#serverthread) | ServerThread(port=None, proto=LO_DEFAULT, reg_methods=True) | | [make_method](#make_method) | A decorator that serves as a more convenient alternative to [Server.add_method](#add_method). | | [struct](#struct) | | | Function | Description | | :------- | :----------- | | `send` | Send a message without requiring a server | | `time` | Return the current time as a floating point number (seconds since January 1, 1900). | --------- ## Address ### ```python Address(addr, addr2=None, proto=LO_UDP) ``` An Address represents a destination for a message Possible forms: * `Address(hostname: str, port: int, proto: [int | str] = LO_UDP`) * `Address(port: int)` # Assumes localhost * `Address(url: str)` # A URL of the form 'osc.udp://hostname:1234/' Create a new `Address` object from the given hostname/port or URL. Raises: AddressError: if the given parameters do not represent a valid address. **Args** * **hostname**: the target's hostname - the name or an IP of the form '127.0.0.0'. * **port**: the port number of the target * **proto**: one of the constants `LO_UDP`, `LO_TCP`, `LO_UNIX` or a string like 'UDP', 'TCP' or 'UNIX' * **url**: a URL in liblo notation, e.g. `'osc.udp://hostname:1234/'`. --------- **Summary** | Property | Description | | :-------- | :----------- | | hostname | The address's hostname. | | port | The address's port number. | | protocol | The address's protocol (one of the constants :const:`UDP`, :const:`TCP`, or :const:`UNIX`). | | url | The address's URL. | | Method | Description | | :------ | :----------- | | [get_hostname](#get_hostname) | The hostname of this Address | | [get_port](#get_port) | The port number of this Address | | [get_protocol](#get_protocol) | The protocol used as an int | | [get_url](#get_url) | This Address as a liblo URL | --------- **Attributes** * **hostname**: The address's hostname. * **port**: The address's port number. * **protocol**: The address's protocol (one of the constants :const:`UDP`, :const:`TCP`, or :const:`UNIX`). * **url**: The address's URL. --------- **Methods** ### get\_hostname ```python Address.get_hostname(self) ``` The hostname of this Address ---------- ### get\_port ```python Address.get_port(self) ``` The port number of this Address ---------- ### get\_protocol ```python Address.get_protocol(self) ``` The protocol used as an int #### Example ```python from pyliblo3 import * address = Address('127.0.0.0', 9876) assert address.get_protocol() == LO_UDP ``` ---------- ### get\_url ```python Address.get_url(self) ``` This Address as a liblo URL --------- ## Bundle ### ```python Bundle(*messages) ``` A bundle of one or more messages to be sent and dispatched together. Possible forms: * `Bundle(*messages)` * `Bundle(timetag: float, *messages)` Create a new `Bundle` object. You can optionally specify a time at which the messages should be dispatched (as an OSC timetag float), and any number of messages to be included in the bundle. **Args** * **timetag** (`float`): optional, speficies the time at which the message should be dispatched * **messages**: any number of `Message`s to include in this `Bundle` --------- **Summary** | Method | Description | | :------ | :----------- | | [add](#add) | Add one or more messages to this bundle | --------- --------- **Methods** ### add ```python Bundle.add(self, *args) ``` Add one or more messages to this bundle Possible forms: * `add(*messages: Message)` * `add(path: str, *args)`, where path is the osc path (for example, '/path1' or '/root/subpath') and `args` are passed directly to `Message` to create a Message to be added to this Bundle Add one or more messages to the bundle. **Args** * **args**: --------- ## Callback ### ```python Callback(func, user_data) ``` Used internally to wrap a python function as a callback **Args** * **func**: the function to call * **user_data**: any python object, will be passed to the callback as the last argument --------- ## Message ### ```python Message(path, *args) ``` An OSC message, consisting of a path and arbitrary arguments. **Args** * **path** (`str`): the path of the message * **args**: any arguments passed will be added to this messag --------- **Summary** | Method | Description | | :------ | :----------- | | [add](#add) | Append the given arguments to this message | --------- --------- **Methods** ### add ```python Message.add(self, *args) ``` Append the given arguments to this message Arguments can be single values or `(typetag, data)` tuples to specify the actual type. This might be needed for numbers, to specify if a float needs to be encoded as a 32-bit (typetag = 'f') or 64-bit float (typetag = 'd'). By default, float numbers are interpreted as 32-bit floats. **Args** * **args**: each argument can be a single value or a tuple `(typetag: str, data: Any)` --------- ## make\_method ### ```python def (path: str | None, types: str, user_data) -> None ``` A decorator that serves as a more convenient alternative to [Server.add_method](#add_method). **Args** * **path** (`str | None`): the message path to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. * **types** (`str`): the argument types to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. * **user_data**: An arbitrary object that will be passed on to the decorated method every time a matching message is received. --------- **Summary** | Method | Description | | :------ | :----------- | | [__init__](#__init__) | make_method.__init__(self, path, types, user_data=None) | --------- --------- **Methods** ### \_\_init\_\_ ```python def __init__(self, path, types, user_data=None) -> None ``` make_method.__init__(self, path, types, user_data=None) **Args** * **path**: * **types**: * **user_data**: (*default*: `None`) --------- ## struct --------- **Summary** | Method | Description | | :------ | :----------- | | [__init__](#__init__) | struct.__init__(self, **kwargs) | --------- --------- **Methods** ### \_\_init\_\_ ```python def __init__(self, kwargs) -> None ``` struct.__init__(self, **kwargs) **Args** * **kwargs**: --------- ## \_ServerBase ### ```python _ServerBase(reg_methods=True) ``` --------- **Summary** | Property | Description | | :-------- | :----------- | | port | The server's port number (int) | | protocol | The server's protocol (one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX`). | | url | The server's URL. | | Method | Description | | :------ | :----------- | | [add_bundle_handlers](#add_bundle_handlers) | Add bundle notification handlers. | | [add_method](#add_method) | Register a callback for OSC messages with matching path and argument types. | | [del_method](#del_method) | Delete a callback function | | [fileno](#fileno) | Return the file descriptor of the server socket | | [get_port](#get_port) | Returns the port number of this server | | [get_protocol](#get_protocol) | Returns the protocol of this server, as an int | | [get_url](#get_url) | Returns the url of the server | | [register_methods](#register_methods) | Called internally during init if reg_methods is True | | [send](#send) | Send a message or bundle from this server to the the given target. | --------- **Attributes** * **port**: The server's port number (int) * **protocol**: The server's protocol (one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX`). * **url**: The server's URL. --------- **Methods** ### add\_bundle\_handlers ```python _ServerBase.add_bundle_handlers(self, start_handler, end_handler, user_data=None) ``` Add bundle notification handlers. **Args** * **start_handler**: a callback which fires when at the start of a bundle. This is called with the bundle's timestamp and user_data. * **end_handler**: a callback which fires when at the end of a bundle. This is called with user_data. * **user_data**: data to pass to the handlers. (*default*: `None`) ---------- ### add\_method ```python _ServerBase.add_method(self, str path, str typespec, func, user_data=None) ``` Register a callback for OSC messages with matching path and argument types. **Args** * **path** (`str`): the message path to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. * **typespec** (`str`): the argument types to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. * **func**: the callback function. This may be a global function, a class method, or any other callable object, pyliblo will know what to do either way. * **user_data**: An arbitrary object that will be passed on to *func* every time a matching message is received. (*default*: `None`) ---------- ### del\_method ```python _ServerBase.del_method(self, path, typespec=None) ``` Delete a callback function Delete a callback function. For both *path* and *typespec*, `None` may be used as a wildcard. **Args** * **path** (`str | None`): the method to delete * **typespec** (`str | None`): the typespec to match, or None to delete any method matching the given path (*default*: `None`) ---------- ### fileno ```python _ServerBase.fileno(self) ``` Return the file descriptor of the server socket **Returns**     (`int`) the file descriptor, or -1 if not supported by the underlying server protocol ---------- ### get\_port ```python _ServerBase.get_port(self) ``` Returns the port number of this server **Returns**     (`int`) port number ---------- ### get\_protocol ```python _ServerBase.get_protocol(self) ``` Returns the protocol of this server, as an int This will be one of `LO_TCP`, `LO_TCP` or `LO_UNIX` **Returns**     (`int`) the protocol as an int ---------- ### get\_url ```python _ServerBase.get_url(self) ``` Returns the url of the server **Returns**     (`str`) url of the server ---------- ### register\_methods ```python _ServerBase.register_methods(self, obj=None) ``` Called internally during init if reg_methods is True This function is usually called automatically by the server's constructor, unless its *reg_methods* parameter was set to `False`. **Args** * **obj**: The object that implements the OSC callbacks to be registered. By default this is the server object itself. (*default*: `None`) ---------- ### send ```python _ServerBase.send(self, target, *args) ``` Send a message or bundle from this server to the the given target. * `send(target, *messages)` * `send(target, path, *args)` Send a message or bundle from this server to the the given target. Arguments may be one or more `Message` or `Bundle` objects, or a single message given by its path and optional arguments. Raises: AddressError: if the given target is invalid. IOError: if the message couldn't be sent. **Args** * **target** (`Address | tuple[str, int] | str`): the address to send the message to; an `Address` object, a port number, a `(hostname, port)` tuple, or a URL. * **args**: --------- ## Server - Base Class: [_ServerBase](#_serverbase) ### ```python Server(port=None, proto=LO_DEFAULT, reg_methods=True) ``` A server that can receive OSC messages, blocking Use [ServerThread](#ServerThread) for an OSC server that runs in its own thread and never blocks. Raises: ServerError: if an error occurs created the underlying liblo server **Args** * **port** (`int | None`): a decimal port number or a UNIX socket path. If omitted, an arbitrary free UDP port will be used. * **proto** (`int | str`): one of LO_UDP, LO_TCP, LO_UNIX or LO_DEFAULT, or one of the strings 'UDP', 'TCP', 'UNIX' * **reg_methods** (`bool`): if True, register any methods decorated with the [make_method](#make_method) decorator --------- **Summary** | Method | Description | | :------ | :----------- | | [free](#free) | Free the underlying server object and close its port. | | [recv](#recv) | Receive and dispatch one OSC message. | --------- --------- **Methods** ### free ```python Server.free(self) ``` Free the underlying server object and close its port. Note that this will also happen automatically when the server is deallocated. ---------- ### recv ```python Server.recv(self, timeout=None) ``` Receive and dispatch one OSC message. Blocking by default, unless *timeout* is specified. **Args** * **timeout** (`int, float`): Time in milliseconds after which the function returns if no messages have been received. May be 0, in which case the function always returns immediately, whether messages have been received or not. (*default*: `None`) **Returns**     `True` if a message was received, otherwise `False`. --------- ## ServerThread - Base Class: [_ServerBase](#_serverbase) ### ```python ServerThread(port=None, proto=LO_DEFAULT, reg_methods=True) ``` Server running in a thread Unlike `Server`, `ServerThread` uses its own thread which runs in the background to dispatch messages. `ServerThread` has the same methods as `Server`, with the exception of `.recv`. Instead, it defines two additional methods `.start` and `.stop`. Raises: ServerError: if creating the server fails, e.g. because the given port could not be opened. !!! note Because liblo creates its own thread to receive and dispatch messages, callback functions will not be run in the main Python thread! **Args** * **port** (`int | str`): a decimal port number or a UNIX socket path. If omitted, an arbitrary free UDP port will be used. * **proto** (`int | str`): one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX` or a corresponding string 'UDP', 'TCP', 'UNIX' * **reg_methods**: if True, register any method decorated with the [make_method](#make_method) decorator --------- **Summary** | Method | Description | | :------ | :----------- | | [free](#free) | Free the underlying server object and close its port. | | [start](#start) | Start the server thread. | | [stop](#stop) | Stop the server thread. | --------- --------- **Methods** ### free ```python ServerThread.free(self) ``` Free the underlying server object and close its port. !!! note This method is called automatically when the server is deallocated. ---------- ### start ```python ServerThread.start(self) ``` Start the server thread. liblo will now start to dispatch any messages it receives. ---------- ### stop ```python ServerThread.stop(self) ``` Stop the server thread. --------- ## send ```python send(target, *args) ``` Send a message without requiring a server The function has two forms: * `send(target, *messages)` * `send(target, path, *args)` Send messages to the the given target, without requiring a server. Arguments may be one or more `Message` or `Bundle` objects, or a single message given by its path and optional arguments. Raises: AddressError: if the given target is invalid IOError: if the message couldn't be sent. **Args** * **target** (`Address | tuple[str, int] | int | str`): the address to send the message to; an `Address` object, a port number, a `(hostname, port)` tuple, or a URL. * **args** (`Any`): the information to send. These are used to construct a message --------- ## time ```python time() ``` Return the current time as a floating point number (seconds since January 1, 1900). **Returns**     (`float`) The liblo timetag as a float, representing seconds since 1900 pyliblo3-master/docs/generatedocs.py000066400000000000000000000026411465273517200200700ustar00rootroot00000000000000#!/usr/bin/env python3 import os import argparse import sys from pathlib import Path import logging import shutil try: import pyliblo3 as liblo from emlib import doctools except ImportError: import textwrap print("\n**WARNING**: Failed to update documentation. The python present in the current environment" " does not have the needed packages (pyliblo3, emlib)\n") sys.exit(1) def findRoot(): p = Path(__file__).parent if (p.parent/"setup.py").exists(): return p.parent if (p/"index.md").exists(): return p.parent if (p/"setup.py").exists(): return p raise RuntimeError(f"Could not locate the root folder, search started at {p}") def main(dest: Path): config = doctools.RenderConfig(splitName=True, includeInheritedMethods=False) markdown = doctools.generateDocsForModule(liblo._liblo, renderConfig=config, title='Reference', includeCustomExceptions=False) open(dest/"Reference.md", "w").write(markdown) if __name__ == "__main__": logging.basicConfig(level="DEBUG") doctools.logger.setLevel("DEBUG") root = findRoot() docsfolder = root / "docs" print("Documentation folder", docsfolder) assert docsfolder.exists() main(docsfolder) if not shutil.which('mkdocs'): print("\n**WARNING**: mkdocs not found, cannot generate HTML docs") else: os.chdir(root) os.system("mkdocs build") pyliblo3-master/docs/index.md000066400000000000000000000017261465273517200165070ustar00rootroot00000000000000# pyliblo3 Welcome to the **pyliblo3** documentation! **pyliblo3** is a cython wrapper for the C library [liblo](). ## Quick Introduction ```python from pyliblo3 import * import time class MyServer(ServerThread): def __init__(self, port=1234): ServerThread.__init__(self, port) @make_method('/foo', 'ifs') def foo_callback(self, path, args): i, f, s = args print(f"Received message '{path}' with arguments: {i=}, {f=}, {s=}") @make_method(None, None) def fallback(self, path, args): print(f"received unknown message '{path}' with {args=}") server = MyServer() server.start() print(f"Server started in its own thread, send messages to {server.port}. Use CTRL-C to stop") while True: send(("127.0.0.0", server.port), "/foo", 10, 1.5, "bar") send(("127.0.0.0", server.port), "/unknown", (3, 4)) time.sleep(1) ``` ---- ## Installation ```bash pip install pyliblo3 ``` pyliblo3-master/docs/requirements.txt000066400000000000000000000000361465273517200203330ustar00rootroot00000000000000emlib>=0.16.0 mkdocs-material pyliblo3-master/examples/000077500000000000000000000000001465273517200157365ustar00rootroot00000000000000pyliblo3-master/examples/example_client.py000077500000000000000000000016061465273517200213070ustar00rootroot00000000000000#!/usr/bin/env python from __future__ import print_function import liblo, sys # send all messages to port 1234 on the local machine try: target = liblo.Address(1234) except liblo.AddressError as err: print(err) sys.exit() # send message "/foo/message1" with int, float and string arguments liblo.send(target, "/foo/bar", 123, 456.789) # send double, int64 and char liblo.send(target, "/foo/message2", ('d', 3.1415), ('h', 2**42), ('c', 'x')) # we can also build a message object first... msg = liblo.Message("/foo/blah") # ... append arguments later... msg.add(123, "foo") # ... and then send it liblo.send(target, msg) # send a list of bytes as a blob blob = [4, 8, 15, 16, 23, 42] liblo.send(target, "/foo/blob", blob) # wrap a message in a bundle, to be dispatched after 2 seconds bundle = liblo.Bundle(liblo.time() + 2.0, liblo.Message("/blubb", 123)) liblo.send(target, bundle) pyliblo3-master/examples/example_server.py000077500000000000000000000021511465273517200213330ustar00rootroot00000000000000#!/usr/bin/env python from __future__ import print_function import liblo, sys # create server, listening on port 1234 try: server = liblo.Server(1234) except liblo.ServerError as err: print(err) sys.exit() def foo_bar_callback(path, args): i, f = args print("/foo/bar: received message '%s' with arguments '%d' and '%f'" % (path, i, f)) def foo_baz_callback(path, args, types, src, data): print("/foo/baz: received message '%s'" % path) print("blob contains %d bytes, user data was '%s'" % (len(args[0]), data)) def fallback(path, args, types, src): print("got unknown message '%s' from '%s'" % (path, src.url)) for a, t in zip(args, types): print("argument of type '%s': %s" % (t, a)) # register method taking an int and a float server.add_method("/foo/bar", 'if', foo_bar_callback) # register method taking a blob, and passing user data to the callback server.add_method("/foo/baz", 'b', foo_baz_callback, "blah") # register a fallback for unhandled messages server.add_method(None, None, fallback) # loop and dispatch messages every 100ms while True: server.recv(100) pyliblo3-master/examples/example_server_deco.py000077500000000000000000000013661465273517200223340ustar00rootroot00000000000000#!/usr/bin/env python from pyliblo3 import * import time class MyServer(ServerThread): def __init__(self, port=1234): ServerThread.__init__(self, port) @make_method('/foo', 'ifs') def foo_callback(self, path, args): i, f, s = args print(f"Received message '{path}' with arguments: {i=}, {f=}, {s=}") @make_method(None, None) def fallback(self, path, args): print(f"received unknown message '{path}' with {args=}") server = MyServer() server.start() print(f"Server started in its own thread, send messages to {server.port}. Use CTRL-C to stop") while True: send(("127.0.0.0", server.port), "/foo", 10, 1.5, "bar") send(("127.0.0.0", server.port), "/unknown", (3, 4)) time.sleep(1) pyliblo3-master/examples/test_server_thread.py000077500000000000000000000021441465273517200222100ustar00rootroot00000000000000#!/usr/bin/env python from __future__ import print_function import liblo import time st = liblo.ServerThread() print("Created Server Thread on Port", st.port) def foo_cb(path, args, types): print("foo_cb():") for a, t in zip(args, types): print("received argument %s of type %s" % (a, t)) def bar_cb(path, args, types, src): print("bar_cb():") print("message from", src.url) print("typespec:", types) for a, t in zip(args, types): print("received argument %s of type %s" % (a, t)) class Blah: def __init__(self, x): self.x = x def baz_cb(self, path, args, types, src, user_data): print("baz_cb():") print(args[0]) print("self.x is", self.x, ", user data was", user_data) st.add_method('/foo', 'ifs', foo_cb) st.add_method('/bar', 'hdc', bar_cb) b = Blah(123) st.add_method('/baz', 'b', b.baz_cb, 456) st.start() liblo.send(st.port, "/foo", 123, 456.789, "buh!") l = 1234567890123456 liblo.send(st.port, "/bar", l, 666, ('c', "x")) time.sleep(1) st.stop() st.start() liblo.send(st.port, "/baz", [1,2,3,4,5,6,7,8,9,10]) time.sleep(1) pyliblo3-master/mkdocs.yml000066400000000000000000000006301465273517200161220ustar00rootroot00000000000000site_name: pyliblo3 theme: name: material features: - navigation.tabs - navigation.sections extra_css: - stylesheets/extra.css markdown_extensions: - toc: toc_depth: 3 - pymdownx.highlight - pymdownx.superfences - admonition use_directory_urls: false repo_url: https://github.com/gesellkammer/pyliblo3 nav: - index.md - Reference.md pyliblo3-master/pyliblo3/000077500000000000000000000000001465273517200156555ustar00rootroot00000000000000pyliblo3-master/pyliblo3/__init__.py000066400000000000000000000011631465273517200177670ustar00rootroot00000000000000from __future__ import absolute_import import platform import os if platform.system() == "Windows": libspath = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'pyliblo3.libs')) if os.path.exists(libspath) and os.path.isdir(libspath): os.add_dll_directory(libspath) else: possible_paths = ['C:/Program Files/liblo/lib', 'C:/Program Files/liblo/bin'] for path in ['C:/Program Files/liblo/lib', 'C:/Program Files/liblo/bin']: if os.path.exists(path) and os.path.isdir(path): os.add_dll_directory(path) del platform del os from ._liblo import * pyliblo3-master/pyliblo3/_liblo.c000066400000000000000000051532001465273517200172670ustar00rootroot00000000000000/* Generated by Cython 3.0.10 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ "/usr/include/lo/lo.h" ], "extra_compile_args": [ "-fno-strict-aliasing", "-Werror-implicit-function-declaration", "-Wfatal-errors" ], "include_dirs": [ "pyliblo3", "/usr/include", "/usr/local/include" ], "libraries": [ "lo" ], "library_dirs": [ "/usr/local/lib" ], "name": "pyliblo3._liblo", "sources": [ "pyliblo3/_liblo.pyx" ] }, "module_name": "pyliblo3._liblo" } 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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.7+ or Python 3.3+. #else #if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API #define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else #define __PYX_EXTRA_ABI_MODULE_NAME "" #endif #define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." #define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX #if defined(GRAALVM_PYTHON) /* For very preliminary testing purposes. Most variables are set the same as PyPy. The existence of this section does not imply that anything works or is even tested */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #elif defined(PYPY_VERSION) #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) #endif #if PY_VERSION_HEX < 0x03090000 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #elif defined(CYTHON_LIMITED_API) #ifdef Py_LIMITED_API #undef __PYX_LIMITED_VERSION_HEX #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_CLINE_IN_TRACEBACK #define CYTHON_CLINE_IN_TRACEBACK 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 1 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #endif #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 1 #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #ifndef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 1 #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #endif #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_GIL #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) #endif #ifndef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #if PY_VERSION_HEX < 0x030400a1 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #elif !defined(CYTHON_USE_TP_FINALIZE) #define CYTHON_USE_TP_FINALIZE 1 #endif #if PY_VERSION_HEX < 0x030600B1 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #elif !defined(CYTHON_USE_DICT_VERSIONS) #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if !defined(CYTHON_VECTORCALL) #define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif #define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED #if defined(__cplusplus) /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(maybe_unused) #define CYTHON_UNUSED [[maybe_unused]] #endif #endif #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_UNUSED_VAR( const T& ) { } # else # define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #ifndef CYTHON_USE_CPP_STD_MOVE #if defined(__cplusplus) && (\ __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) #define CYTHON_USE_CPP_STD_MOVE 1 #else #define CYTHON_USE_CPP_STD_MOVE 0 #endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; #endif #endif #if _MSC_VER < 1300 #ifdef _WIN64 typedef unsigned long long __pyx_uintptr_t; #else typedef unsigned int __pyx_uintptr_t; #endif #else #ifdef _WIN64 typedef unsigned __int64 __pyx_uintptr_t; #else typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else #include typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifdef __cplusplus template struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) #else #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) #endif #if CYTHON_COMPILING_IN_PYPY == 1 #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) #else #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) #endif #define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_DefaultClassType PyClass_Type #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *exception_table = NULL; PyObject *types_module=NULL, *code_type=NULL, *result=NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 PyObject *version_info; PyObject *py_minor_version = NULL; #endif long minor_version = 0; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 minor_version = 11; #else if (!(version_info = PySys_GetObject("version_info"))) goto end; if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; minor_version = PyLong_AsLong(py_minor_version); Py_DECREF(py_minor_version); if (minor_version == -1 && PyErr_Occurred()) goto end; #endif if (!(types_module = PyImport_ImportModule("types"))) goto end; if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; if (minor_version <= 7) { (void)p; result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, c, n, v, fn, name, fline, lnos, fv, cell); } else if (minor_version <= 10) { result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, c, n, v, fn, name, fline, lnos, fv, cell); } else { if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } end: Py_XDECREF(code_type); Py_XDECREF(exception_table); Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } return result; } #ifndef CO_OPTIMIZED #define CO_OPTIMIZED 0x0001 #endif #ifndef CO_NEWLOCALS #define CO_NEWLOCALS 0x0002 #endif #ifndef CO_VARARGS #define CO_VARARGS 0x0004 #endif #ifndef CO_VARKEYWORDS #define CO_VARKEYWORDS 0x0008 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x0200 #endif #ifndef CO_GENERATOR #define CO_GENERATOR 0x0020 #endif #ifndef CO_COROUTINE #define CO_COROUTINE 0x0080 #endif #elif PY_VERSION_HEX >= 0x030B0000 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyCodeObject *result; PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); if (!empty_bytes) return NULL; result = #if PY_VERSION_HEX >= 0x030C0000 PyUnstable_Code_NewWithPosOnlyArgs #else PyCode_NewWithPosOnlyArgs #endif (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); Py_DECREF(empty_bytes); return result; } #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #endif #if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) #else #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) #define __Pyx_Py_Is(x, y) Py_Is(x, y) #else #define __Pyx_Py_Is(x, y) ((x) == (y)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) #else #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) #else #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) #else #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) #endif #define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) #if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) #else #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef CO_COROUTINE #define CO_COROUTINE 0x80 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef Py_TPFLAGS_SEQUENCE #define Py_TPFLAGS_SEQUENCE 0 #endif #ifndef Py_TPFLAGS_MAPPING #define Py_TPFLAGS_MAPPING 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #if PY_VERSION_HEX >= 0x030d00A4 # define __Pyx_PyCFunctionFast PyCFunctionFast # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords #else # define __Pyx_PyCFunctionFast _PyCFunctionFast # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #endif #if CYTHON_METH_FASTCALL #define __Pyx_METH_FASTCALL METH_FASTCALL #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords #else #define __Pyx_METH_FASTCALL METH_VARARGS #define __Pyx_PyCFunction_FastCall PyCFunction #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords #endif #if CYTHON_VECTORCALL #define __pyx_vectorcallfunc vectorcallfunc #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) #elif CYTHON_BACKPORT_VECTORCALL typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames); #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) #else #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) #endif #if PY_MAJOR_VERSION >= 0x030900B1 #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #else #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) #endif #define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) #elif !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) #endif #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; } #endif static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { #if CYTHON_COMPILING_IN_LIMITED_API return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) #if __PYX_LIMITED_VERSION_HEX < 0x030900B1 #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) #define __Pyx_PyCMethod PyCMethod #endif #ifndef METH_METHOD #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyThreadState_Current PyThreadState_Get() #elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); if (!result) Py_FatalError("Couldn't find the module state"); return result; } #endif #define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) #else #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if PY_MAJOR_VERSION < 3 #if CYTHON_COMPILING_IN_PYPY #if PYPY_VERSION_NUM < 0x07030600 #if defined(__cplusplus) && __cplusplus >= 201402L [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] #elif defined(__GNUC__) || defined(__clang__) __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) #elif defined(_MSC_VER) __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) #endif static CYTHON_INLINE int PyGILState_Check(void) { return 0; } #else // PYPY_VERSION_NUM < 0x07030600 #endif // PYPY_VERSION_NUM < 0x07030600 #else static CYTHON_INLINE int PyGILState_Check(void) { PyThreadState * tstate = _PyThreadState_Current; return tstate && (tstate == PyGILState_GetThisThreadState()); } #endif #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); if (res == NULL) PyErr_Clear(); return res; } #elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError #define __Pyx_PyDict_GetItemStr PyDict_GetItem #else static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { #if CYTHON_COMPILING_IN_PYPY return PyDict_GetItem(dict, name); #else PyDictEntry *ep; PyDictObject *mp = (PyDictObject*) dict; long hash = ((PyStringObject *) name)->ob_shash; assert(hash != -1); ep = (mp->ma_lookup)(mp, name, hash); if (ep == NULL) { return NULL; } return ep->me_value; #endif } #define __Pyx_PyDict_GetItemStr PyDict_GetItem #endif #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) #else #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 #define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ PyTypeObject *type = Py_TYPE((PyObject*)obj);\ assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ PyObject_GC_Del(obj);\ Py_DECREF(type);\ } #else #define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) #define __Pyx_PyUnicode_DATA(u) ((void*)u) #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) #elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_READY(op) (0) #else #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #else #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY #if !defined(PyUnicode_DecodeUnicodeEscape) #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) #endif #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) #undef PyUnicode_Contains #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PySequence_ListKeepNew(obj)\ (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #else #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #else static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { PyObject *module = PyImport_AddModule(name); Py_XINCREF(module); return module; } #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define __Pyx_Py3Int_Check(op) PyLong_Check(op) #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #else #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifdef CYTHON_EXTERN_C #undef __PYX_EXTERN_C #define __PYX_EXTERN_C CYTHON_EXTERN_C #elif defined(__PYX_EXTERN_C) #ifdef _MSC_VER #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") #else #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. #endif #else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__pyliblo3___liblo #define __PYX_HAVE_API__pyliblo3___liblo /* Early includes */ #include #include #include #include "lo/lo.h" #include #include "pythread.h" #include #include #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_VERSION_HEX >= 0x030C00A7 #ifndef _PyLong_SIGN_MASK #define _PyLong_SIGN_MASK 3 #endif #ifndef _PyLong_NON_SIZE_BITS #define _PyLong_NON_SIZE_BITS 3 #endif #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_SignedDigitCount(x)\ ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) #else #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) #endif typedef Py_ssize_t __Pyx_compact_pylong; typedef size_t __Pyx_compact_upylong; #else #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) #define __Pyx_PyLong_CompactValue(x)\ ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) typedef sdigit __Pyx_compact_pylong; typedef digit __Pyx_compact_upylong; #endif #if PY_VERSION_HEX >= 0x030C00A5 #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) #else #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) #endif #endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } #if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; #endif static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; /* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "pyliblo3/_liblo.pyx", "contextvars.pxd", "", "type.pxd", "bool.pxd", "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 #define __Pyx_FastGIL_Remember() #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() /* #### Code section: numeric_typedefs ### */ /* #### Code section: complex_type_declarations ### */ /* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_8pyliblo3_6_liblo_Callback; struct __pyx_obj_8pyliblo3_6_liblo__ServerBase; struct __pyx_obj_8pyliblo3_6_liblo_Server; struct __pyx_obj_8pyliblo3_6_liblo_ServerThread; struct __pyx_obj_8pyliblo3_6_liblo_Address; struct __pyx_obj_8pyliblo3_6_liblo__Blob; struct __pyx_obj_8pyliblo3_6_liblo_Message; struct __pyx_obj_8pyliblo3_6_liblo_Bundle; 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; }; /* "pyliblo3/_liblo.pyx":76 * * * cdef class Callback: # <<<<<<<<<<<<<< * """ * Used internally to wrap a python function as a callback */ struct __pyx_obj_8pyliblo3_6_liblo_Callback { PyObject_HEAD PyObject *func; PyObject *user_data; int numargs; int has_varargs; }; /* "pyliblo3/_liblo.pyx":116 * * # forward declarations * cdef class _ServerBase # <<<<<<<<<<<<<< * cdef class Address * cdef class Message */ struct __pyx_obj_8pyliblo3_6_liblo__ServerBase { PyObject_HEAD struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *__pyx_vtab; lo_server _server; PyObject *_keep_refs; }; /* "pyliblo3/_liblo.pyx":589 * * * cdef class Server(_ServerBase): # <<<<<<<<<<<<<< * """ * A server that can receive OSC messages, blocking */ struct __pyx_obj_8pyliblo3_6_liblo_Server { struct __pyx_obj_8pyliblo3_6_liblo__ServerBase __pyx_base; }; /* "pyliblo3/_liblo.pyx":668 * * * cdef class ServerThread(_ServerBase): # <<<<<<<<<<<<<< * """ * Server running in a thread */ struct __pyx_obj_8pyliblo3_6_liblo_ServerThread { struct __pyx_obj_8pyliblo3_6_liblo__ServerBase __pyx_base; lo_server_thread _server_thread; }; /* "pyliblo3/_liblo.pyx":117 * # forward declarations * cdef class _ServerBase * cdef class Address # <<<<<<<<<<<<<< * cdef class Message * cdef class Bundle */ struct __pyx_obj_8pyliblo3_6_liblo_Address { PyObject_HEAD lo_address _address; }; /* "pyliblo3/_liblo.pyx":888 * ################################################################################ * * cdef class _Blob: # <<<<<<<<<<<<<< * cdef lo_blob _blob * */ struct __pyx_obj_8pyliblo3_6_liblo__Blob { PyObject_HEAD lo_blob _blob; }; /* "pyliblo3/_liblo.pyx":118 * cdef class _ServerBase * cdef class Address * cdef class Message # <<<<<<<<<<<<<< * cdef class Bundle * */ struct __pyx_obj_8pyliblo3_6_liblo_Message { PyObject_HEAD struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message *__pyx_vtab; PyObject *_path; lo_message _message; PyObject *_keep_refs; }; /* "pyliblo3/_liblo.pyx":119 * cdef class Address * cdef class Message * cdef class Bundle # <<<<<<<<<<<<<< * * */ struct __pyx_obj_8pyliblo3_6_liblo_Bundle { PyObject_HEAD lo_bundle _bundle; PyObject *_keep_refs; }; /* "pyliblo3/_liblo.pyx":359 * # common base class for both Server and ServerThread * * cdef class _ServerBase: # <<<<<<<<<<<<<< * cdef lo_server _server * cdef list _keep_refs */ struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase { PyObject *(*_check)(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *); }; static struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *__pyx_vtabptr_8pyliblo3_6_liblo__ServerBase; /* "pyliblo3/_liblo.pyx":917 * * * cdef class Message: # <<<<<<<<<<<<<< * """ * An OSC message, consisting of a path and arbitrary arguments. */ struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message { PyObject *(*_add)(struct __pyx_obj_8pyliblo3_6_liblo_Message *, PyObject *, PyObject *); PyObject *(*_add_auto)(struct __pyx_obj_8pyliblo3_6_liblo_Message *, PyObject *); }; static struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message *__pyx_vtabptr_8pyliblo3_6_liblo_Message; /* "pyliblo3/_liblo.pyx":589 * * * cdef class Server(_ServerBase): # <<<<<<<<<<<<<< * """ * A server that can receive OSC messages, blocking */ struct __pyx_vtabstruct_8pyliblo3_6_liblo_Server { struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase __pyx_base; }; static struct __pyx_vtabstruct_8pyliblo3_6_liblo_Server *__pyx_vtabptr_8pyliblo3_6_liblo_Server; /* "pyliblo3/_liblo.pyx":668 * * * cdef class ServerThread(_ServerBase): # <<<<<<<<<<<<<< * """ * Server running in a thread */ struct __pyx_vtabstruct_8pyliblo3_6_liblo_ServerThread { struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase __pyx_base; }; static struct __pyx_vtabstruct_8pyliblo3_6_liblo_ServerThread *__pyx_vtabptr_8pyliblo3_6_liblo_ServerThread; /* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, Py_ssize_t); void (*DECREF)(void*, PyObject*, Py_ssize_t); void (*GOTREF)(void*, PyObject*, Py_ssize_t); void (*GIVEREF)(void*, PyObject*, Py_ssize_t); void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ } #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_Py_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; Py_XDECREF(tmp);\ } while (0) #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #if PY_VERSION_HEX >= 0x030C00A6 #define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) #else #define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) #endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) #define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* TupleAndListFromArray.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* fastcall.proto */ #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) #else #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) #endif #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) #else #define __Pyx_Arg_NewRef_VARARGS(arg) arg #define __Pyx_Arg_XDECREF_VARARGS(arg) #endif #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) #define __Pyx_KwValues_VARARGS(args, nargs) NULL #define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) #define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) #if CYTHON_METH_FASTCALL #define __Pyx_Arg_FASTCALL(args, i) args[i] #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); #else #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs to have the same reference counting */ #define __Pyx_Arg_XDECREF_FASTCALL(arg) #else #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) #endif #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS #define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) #else #define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif /* 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); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* PyObjectFormatSimple.proto */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #elif PY_MAJOR_VERSION < 3 #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ PyObject_Format(s, f)) #elif CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ PyObject_Format(s, f)) #else #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #endif /* JoinPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char); /* 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); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) do {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) #define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectSetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* PyObjectCallNoArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto */ #define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ (likely(is_tuple || PyTuple_Check(tuple)) ?\ (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif /* 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 *); /* RaiseUnexpectedTypeError.proto */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* pybytes_as_double.proto */ static double __Pyx_SlowPyString_AsDouble(PyObject *obj); static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length); static CYTHON_INLINE double __Pyx_PyBytes_AsDouble(PyObject *obj) { char* as_c_string; Py_ssize_t size; #if CYTHON_ASSUME_SAFE_MACROS as_c_string = PyBytes_AS_STRING(obj); size = PyBytes_GET_SIZE(obj); #else if (PyBytes_AsStringAndSize(obj, &as_c_string, &size) < 0) { return (double)-1; } #endif return __Pyx__PyBytes_AsDouble(obj, as_c_string, size); } static CYTHON_INLINE double __Pyx_PyByteArray_AsDouble(PyObject *obj) { char* as_c_string; Py_ssize_t size; #if CYTHON_ASSUME_SAFE_MACROS as_c_string = PyByteArray_AS_STRING(obj); size = PyByteArray_GET_SIZE(obj); #else as_c_string = PyByteArray_AsString(obj); if (as_c_string == NULL) { return (double)-1; } size = PyByteArray_Size(obj); #endif return __Pyx__PyBytes_AsDouble(obj, as_c_string, size); } /* pyunicode_as_double.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS static const char* __Pyx__PyUnicode_AsDouble_Copy(const void* data, const int kind, char* buffer, Py_ssize_t start, Py_ssize_t end) { int last_was_punctuation; Py_ssize_t i; last_was_punctuation = 1; for (i=start; i <= end; i++) { Py_UCS4 chr = PyUnicode_READ(kind, data, i); int is_punctuation = (chr == '_') | (chr == '.'); *buffer = (char)chr; buffer += (chr != '_'); if (unlikely(chr > 127)) goto parse_failure; if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure; last_was_punctuation = is_punctuation; } if (unlikely(last_was_punctuation)) goto parse_failure; *buffer = '\0'; return buffer; parse_failure: return NULL; } static double __Pyx__PyUnicode_AsDouble_inf_nan(const void* data, int kind, Py_ssize_t start, Py_ssize_t length) { int matches = 1; Py_UCS4 chr; Py_UCS4 sign = PyUnicode_READ(kind, data, start); int is_signed = (sign == '-') | (sign == '+'); start += is_signed; length -= is_signed; switch (PyUnicode_READ(kind, data, start)) { #ifdef Py_NAN case 'n': case 'N': if (unlikely(length != 3)) goto parse_failure; chr = PyUnicode_READ(kind, data, start+1); matches &= (chr == 'a') | (chr == 'A'); chr = PyUnicode_READ(kind, data, start+2); matches &= (chr == 'n') | (chr == 'N'); if (unlikely(!matches)) goto parse_failure; return (sign == '-') ? -Py_NAN : Py_NAN; #endif case 'i': case 'I': if (unlikely(length < 3)) goto parse_failure; chr = PyUnicode_READ(kind, data, start+1); matches &= (chr == 'n') | (chr == 'N'); chr = PyUnicode_READ(kind, data, start+2); matches &= (chr == 'f') | (chr == 'F'); if (likely(length == 3 && matches)) return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; if (unlikely(length != 8)) goto parse_failure; chr = PyUnicode_READ(kind, data, start+3); matches &= (chr == 'i') | (chr == 'I'); chr = PyUnicode_READ(kind, data, start+4); matches &= (chr == 'n') | (chr == 'N'); chr = PyUnicode_READ(kind, data, start+5); matches &= (chr == 'i') | (chr == 'I'); chr = PyUnicode_READ(kind, data, start+6); matches &= (chr == 't') | (chr == 'T'); chr = PyUnicode_READ(kind, data, start+7); matches &= (chr == 'y') | (chr == 'Y'); if (unlikely(!matches)) goto parse_failure; return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': break; default: goto parse_failure; } return 0.0; parse_failure: return -1.0; } static double __Pyx_PyUnicode_AsDouble_WithSpaces(PyObject *obj) { double value; const char *last; char *end; Py_ssize_t start, length = PyUnicode_GET_LENGTH(obj); const int kind = PyUnicode_KIND(obj); const void* data = PyUnicode_DATA(obj); start = 0; while (Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, start))) start++; while (start < length - 1 && Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, length - 1))) length--; length -= start; if (unlikely(length <= 0)) goto fallback; value = __Pyx__PyUnicode_AsDouble_inf_nan(data, kind, start, length); if (unlikely(value == -1.0)) goto fallback; if (value != 0.0) return value; if (length < 40) { char number[40]; last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length); if (unlikely(!last)) goto fallback; value = PyOS_string_to_double(number, &end, NULL); } else { char *number = (char*) PyMem_Malloc((length + 1) * sizeof(char)); if (unlikely(!number)) goto fallback; last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length); if (unlikely(!last)) { PyMem_Free(number); goto fallback; } value = PyOS_string_to_double(number, &end, NULL); PyMem_Free(number); } if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) { return value; } fallback: return __Pyx_SlowPyString_AsDouble(obj); } #endif static CYTHON_INLINE double __Pyx_PyUnicode_AsDouble(PyObject *obj) { #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS if (unlikely(__Pyx_PyUnicode_READY(obj) == -1)) return (double)-1; if (likely(PyUnicode_IS_ASCII(obj))) { const char *s; Py_ssize_t length; s = PyUnicode_AsUTF8AndSize(obj, &length); return __Pyx__PyBytes_AsDouble(obj, s, length); } return __Pyx_PyUnicode_AsDouble_WithSpaces(obj); #else return __Pyx_SlowPyString_AsDouble(obj); #endif } /* pystring_as_double.proto */ static CYTHON_INLINE double __Pyx_PyString_AsDouble(PyObject *obj) { #if PY_MAJOR_VERSION >= 3 (void)__Pyx_PyBytes_AsDouble; return __Pyx_PyUnicode_AsDouble(obj); #else (void)__Pyx_PyUnicode_AsDouble; return __Pyx_PyBytes_AsDouble(obj); #endif } /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 L->ob_item[len] = x; #else PyList_SET_ITEM(list, len, x); #endif __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* SliceTupleAndList.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); #else #define __Pyx_PyList_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) #define __Pyx_PyTuple_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) #endif /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif /* 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 /* PyObjectCall2Args.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectCallMethod1.proto */ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); /* append.proto */ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); /* 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 /* 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); /* PyObject_Str.proto */ #define __Pyx_PyObject_Str(obj)\ (likely(PyString_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) /* UnpackUnboundCMethod.proto */ typedef struct { PyObject *type; PyObject **method_name; PyCFunction func; PyObject *method; int flag; } __Pyx_CachedCFunction; /* CallUnboundCMethod0.proto */ static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CallUnboundCMethod0(cfunc, self)\ (likely((cfunc)->func) ?\ (likely((cfunc)->flag == METH_NOARGS) ? (*((cfunc)->func))(self, NULL) :\ (PY_VERSION_HEX >= 0x030600B1 && likely((cfunc)->flag == METH_FASTCALL) ?\ (PY_VERSION_HEX >= 0x030700A0 ?\ (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0) :\ (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL)) :\ (PY_VERSION_HEX >= 0x030700A0 && (cfunc)->flag == (METH_FASTCALL | METH_KEYWORDS) ?\ (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL) :\ (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ? ((*(PyCFunctionWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\ ((cfunc)->flag == METH_VARARGS ? (*((cfunc)->func))(self, __pyx_empty_tuple) :\ __Pyx__CallUnboundCMethod0(cfunc, self)))))) :\ __Pyx__CallUnboundCMethod0(cfunc, self)) #else #define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) #endif /* UnicodeAsUCS4.proto */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*); /* object_ord.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyObject_Ord(c)\ (likely(PyUnicode_Check(c)) ? (long)__Pyx_PyUnicode_AsPy_UCS4(c) : __Pyx__PyObject_Ord(c)) #else #define __Pyx_PyObject_Ord(c) __Pyx__PyObject_Ord(c) #endif static long __Pyx__PyObject_Ord(PyObject* c); /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* pyobject_as_double.proto */ static double __Pyx__PyObject_AsDouble(PyObject* obj); #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_AsDouble(obj)\ (likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) :\ likely(PyInt_CheckExact(obj)) ?\ PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) #else #define __Pyx_PyObject_AsDouble(obj)\ ((likely(PyFloat_CheckExact(obj))) ? PyFloat_AS_DOUBLE(obj) :\ likely(PyLong_CheckExact(obj)) ?\ PyLong_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) #endif /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* 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); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetupReduce.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); /* GetVTable.proto */ static void* __Pyx_GetVtable(PyTypeObject *type); /* MergeVTables.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_MergeVtables(PyTypeObject *type); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 #define __PYX_HAVE_RT_ImportType_proto_3_0_10 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L #include #endif #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L #define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) #else #define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) #endif enum __Pyx_ImportType_CheckSize_3_0_10 { __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 }; static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); #endif /* ImportDottedModule.proto */ static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); #endif /* PatchModuleWithCoroutine.proto */ static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); /* PatchInspect.proto */ static PyObject* __Pyx_patch_inspect(PyObject* module); /* SetNameInClass.proto */ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) #elif CYTHON_COMPILING_IN_CPYTHON #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) #else #define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) #endif /* CalculateMetaclass.proto */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); /* 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); /* Py3UpdateBases.proto */ static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); #endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ #if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_char(unsigned char value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint8_t(uint8_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE uint8_t __Pyx_PyInt_As_uint8_t(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value); /* CIntFromPy.proto */ static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *); /* FormatTypeName.proto */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%U" static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) #else typedef const char *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%.200s" #define __Pyx_PyType_GetName(tp) ((tp)->tp_name) #define __Pyx_DECREF_TypeName(obj) #endif /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) #define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static unsigned long __Pyx_get_runtime_version(void); static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* 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 PyObject *__pyx_f_8pyliblo3_6_liblo_11_ServerBase__check(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_8pyliblo3_6_liblo_7Message__add(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_type, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_f_8pyliblo3_6_liblo_7Message__add_auto(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_value); /* proto*/ /* Module declarations from "libc.stdint" */ /* Module declarations from "libc.string" */ /* Module declarations from "libc.stdio" */ /* Module declarations from "cpython.version" */ /* Module declarations from "__builtin__" */ /* Module declarations from "cpython.type" */ /* Module declarations from "cpython.object" */ /* Module declarations from "cpython.ref" */ /* Module declarations from "cpython.exc" */ /* Module declarations from "cpython.module" */ /* Module declarations from "cpython.mem" */ /* Module declarations from "cpython.tuple" */ /* Module declarations from "cpython.list" */ /* Module declarations from "cpython.sequence" */ /* Module declarations from "cpython.mapping" */ /* Module declarations from "cpython.iterator" */ /* Module declarations from "cpython.number" */ /* Module declarations from "cpython.int" */ /* Module declarations from "__builtin__" */ /* Module declarations from "cpython.bool" */ /* Module declarations from "cpython.long" */ /* Module declarations from "cpython.float" */ /* Module declarations from "__builtin__" */ /* Module declarations from "cpython.complex" */ /* Module declarations from "cpython.string" */ /* Module declarations from "libc.stddef" */ /* Module declarations from "cpython.unicode" */ /* Module declarations from "cpython.pyport" */ /* Module declarations from "cpython.dict" */ /* Module declarations from "cpython.instance" */ /* Module declarations from "cpython.function" */ /* Module declarations from "cpython.method" */ /* Module declarations from "cpython.weakref" */ /* Module declarations from "cpython.getargs" */ /* Module declarations from "cpython.pythread" */ /* Module declarations from "cpython.pystate" */ /* Module declarations from "cpython.cobject" */ /* Module declarations from "cpython.oldbuffer" */ /* Module declarations from "cpython.set" */ /* Module declarations from "cpython.buffer" */ /* Module declarations from "cpython.bytes" */ /* Module declarations from "cpython.pycapsule" */ /* Module declarations from "cpython.contextvars" */ /* Module declarations from "cpython" */ /* Module declarations from "libc.stdlib" */ /* Module declarations from "libc.math" */ /* Module declarations from "_liblo" */ /* Module declarations from "pyliblo3._liblo" */ static CYTHON_INLINE PyObject *__pyx_f_8pyliblo3_6_liblo__decode(PyObject *); /*proto*/ static PyObject *__pyx_f_8pyliblo3_6_liblo__encode(PyObject *); /*proto*/ static lo_timetag __pyx_f_8pyliblo3_6_liblo__double_to_timetag(double); /*proto*/ static double __pyx_f_8pyliblo3_6_liblo__timetag_to_double(lo_timetag); /*proto*/ static PyObject *__pyx_f_8pyliblo3_6_liblo__send(PyObject *, struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *, PyObject *); /*proto*/ static int __pyx_f_8pyliblo3_6_liblo__msg_callback(const char *, const char *, lo_arg **, int, lo_message, void *); /*proto*/ static int __pyx_f_8pyliblo3_6_liblo__bundle_start_callback(lo_timetag, void *); /*proto*/ static int __pyx_f_8pyliblo3_6_liblo__bundle_end_callback(void *); /*proto*/ static void __pyx_f_8pyliblo3_6_liblo__err_handler(int, const char *, const char *); /*proto*/ static PyObject *__pyx_f_8pyliblo3_6_liblo___pyx_unpickle_Callback__set_state(struct __pyx_obj_8pyliblo3_6_liblo_Callback *, PyObject *); /*proto*/ /* #### Code section: typeinfo ### */ /* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "pyliblo3._liblo" extern int __pyx_module_is_main_pyliblo3___liblo; int __pyx_module_is_main_pyliblo3___liblo = 0; /* Implementation of "pyliblo3._liblo" */ /* #### Code section: global_var ### */ static PyObject *__pyx_builtin_property; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_IOError; static PyObject *__pyx_builtin_chr; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_OverflowError; /* #### Code section: string_decls ### */ static const char __pyx_k_b[] = "b"; static const char __pyx_k_e[] = "e"; static const char __pyx_k_f[] = "f"; static const char __pyx_k_k[] = "k"; static const char __pyx_k_m[] = "m"; static const char __pyx_k_p[] = "p"; static const char __pyx_k_r[] = "r"; static const char __pyx_k_s[] = ": %s"; static const char __pyx_k_t[] = "t"; static const char __pyx_k_v[] = "v"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_cb[] = "cb"; static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_s2[] = "s2"; static const char __pyx_k_tt[] = "tt"; static const char __pyx_k_TCP[] = "TCP"; static const char __pyx_k_UDP[] = "UDP"; static const char __pyx_k__11[] = "."; static const char __pyx_k__12[] = "*"; static const char __pyx_k__88[] = "?"; static const char __pyx_k_add[] = "add"; static const char __pyx_k_arg[] = "arg"; static const char __pyx_k_arr[] = "arr"; static const char __pyx_k_chr[] = "chr"; static const char __pyx_k_doc[] = "__doc__"; static const char __pyx_k_get[] = "__get__"; static const char __pyx_k_inf[] = "inf"; static const char __pyx_k_key[] = "key"; static const char __pyx_k_msg[] = "msg"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_num[] = "num"; static const char __pyx_k_obj[] = "obj"; static const char __pyx_k_ref[] = "ref"; static const char __pyx_k_s_2[] = "s"; static const char __pyx_k_str[] = "__str__"; static const char __pyx_k_tmp[] = "tmp"; static const char __pyx_k_Blob[] = "_Blob"; static const char __pyx_k_UNIX[] = "UNIX"; static const char __pyx_k_addr[] = "addr"; static const char __pyx_k_args[] = "args"; static const char __pyx_k_call[] = "__call__"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_free[] = "free"; static const char __pyx_k_func[] = "__func__"; static const char __pyx_k_in_s[] = " in %s"; static const char __pyx_k_init[] = "__init__"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_path[] = "path"; static const char __pyx_k_port[] = "port"; static const char __pyx_k_recv[] = "recv"; static const char __pyx_k_self[] = "self"; static const char __pyx_k_send[] = "send"; static const char __pyx_k_sort[] = "sort"; static const char __pyx_k_spec[] = "spec"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_time[] = "time"; static const char __pyx_k_Proto[] = "Proto "; static const char __pyx_k_addr2[] = "addr2"; static const char __pyx_k_class[] = "__class__"; static const char __pyx_k_items[] = "items"; static const char __pyx_k_proto[] = "proto"; static const char __pyx_k_slots[] = "__slots__"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_state[] = "state"; static const char __pyx_k_super[] = "super"; static const char __pyx_k_types[] = "types"; static const char __pyx_k_where[] = "where"; static const char __pyx_k_0_16_1[] = "0.16.1"; static const char __pyx_k_Bundle[] = "Bundle"; static const char __pyx_k_Server[] = "Server"; static const char __pyx_k_append[] = "append"; static const char __pyx_k_decode[] = "decode"; static const char __pyx_k_dict_2[] = "_dict"; static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_fileno[] = "fileno"; static const char __pyx_k_func_2[] = "_func"; static const char __pyx_k_func_3[] = "func"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_kwargs[] = "kwargs"; static const char __pyx_k_module[] = "__module__"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_self_2[] = "__self__"; static const char __pyx_k_spec_2[] = "__spec__"; static const char __pyx_k_struct[] = "struct"; static const char __pyx_k_target[] = "target"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_Address[] = "Address"; static const char __pyx_k_IOError[] = "IOError"; static const char __pyx_k_Message[] = "Message"; static const char __pyx_k_cb_data[] = "cb_data"; static const char __pyx_k_counter[] = "counter"; static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_get_url[] = "get_url"; static const char __pyx_k_inspect[] = "_inspect"; static const char __pyx_k_isdigit[] = "isdigit"; static const char __pyx_k_message[] = "message"; static const char __pyx_k_methods[] = "methods"; static const char __pyx_k_prepare[] = "__prepare__"; static const char __pyx_k_timeout[] = "timeout"; static const char __pyx_k_varargs[] = "varargs"; static const char __pyx_k_version[] = "__version__"; static const char __pyx_k_weakref[] = "_weakref"; static const char __pyx_k_Callback[] = "Callback"; static const char __pyx_k_end_func[] = "end_func"; static const char __pyx_k_get_port[] = "get_port"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_ismethod[] = "ismethod"; static const char __pyx_k_messages[] = "messages"; static const char __pyx_k_property[] = "property"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_qualname[] = "__qualname__"; static const char __pyx_k_set_name[] = "__set_name__"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_typespec[] = "typespec"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_counter_2[] = "_counter"; static const char __pyx_k_exception[] = "__exception"; static const char __pyx_k_inspect_2[] = "inspect"; static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_metaclass[] = "__metaclass__"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_user_data[] = "user_data"; static const char __pyx_k_weakref_2[] = "weakref"; static const char __pyx_k_Bundle_add[] = "Bundle.add"; static const char __pyx_k_ServerBase[] = "_ServerBase"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_add_method[] = "add_method"; static const char __pyx_k_del_method[] = "del_method"; static const char __pyx_k_getmembers[] = "getmembers"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_start_func[] = "start_func"; static const char __pyx_k_Message_add[] = "Message.add"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_ServerError[] = "ServerError"; static const char __pyx_k_Server_free[] = "Server.free"; static const char __pyx_k_Server_recv[] = "Server.recv"; static const char __pyx_k_end_handler[] = "end_handler"; static const char __pyx_k_make_method[] = "make_method"; static const char __pyx_k_method_spec[] = "_method_spec"; static const char __pyx_k_mro_entries[] = "__mro_entries__"; static const char __pyx_k_reg_methods[] = "reg_methods"; static const char __pyx_k_AddressError[] = "AddressError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_ServerThread[] = "ServerThread"; static const char __pyx_k_get_hostname[] = "get_hostname"; static const char __pyx_k_get_protocol[] = "get_protocol"; static const char __pyx_k_initializing[] = "_initializing"; static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_stringsource[] = ""; static const char __pyx_k_use_setstate[] = "use_setstate"; static const char __pyx_k_OverflowError[] = "OverflowError"; static const char __pyx_k_blob_is_empty[] = "blob is empty"; static const char __pyx_k_init_subclass[] = "__init_subclass__"; static const char __pyx_k_invalid_URL_s[] = "invalid URL '%s'"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_start_handler[] = "start_handler"; static const char __pyx_k_struct___init[] = "struct.__init__"; static const char __pyx_k_getfullargspec[] = "getfullargspec"; static const char __pyx_k_server_error_d[] = "server error %d"; static const char __pyx_k_weakref_method[] = "_weakref_method"; static const char __pyx_k_Address_get_url[] = "Address.get_url"; static const char __pyx_k_ServerBase_send[] = "_ServerBase.send"; static const char __pyx_k_address_error_s[] = "address error: %s"; static const char __pyx_k_invalid_timetag[] = "invalid timetag"; static const char __pyx_k_protostr_to_int[] = "_protostr_to_int"; static const char __pyx_k_pyliblo3__liblo[] = "pyliblo3._liblo"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_Address_get_port[] = "Address.get_port"; static const char __pyx_k_invalid_protocol[] = "invalid protocol"; static const char __pyx_k_register_methods[] = "register_methods"; static const char __pyx_k_sending_failed_s[] = "sending failed: %s"; static const char __pyx_k_ServerBase_fileno[] = "_ServerBase.fileno"; static const char __pyx_k_ServerError___str[] = "ServerError.__str__"; static const char __pyx_k_ServerThread_free[] = "ServerThread.free"; static const char __pyx_k_ServerThread_stop[] = "ServerThread.stop"; static const char __pyx_k_AddressError___str[] = "AddressError.__str__"; static const char __pyx_k_ServerBase_get_url[] = "_ServerBase.get_url"; static const char __pyx_k_ServerError___init[] = "ServerError.__init__"; static const char __pyx_k_ServerThread_start[] = "ServerThread.start"; 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_make_method___call[] = "make_method.__call__"; static const char __pyx_k_make_method___init[] = "make_method.__init__"; static const char __pyx_k_AddressError___init[] = "AddressError.__init__"; static const char __pyx_k_ServerBase_get_port[] = "_ServerBase.get_port"; static const char __pyx_k_add_bundle_handlers[] = "add_bundle_handlers"; static const char __pyx_k_pyliblo3__liblo_pyx[] = "pyliblo3/_liblo.pyx"; static const char __pyx_k_weakref_method_func[] = "_weakref_method.func"; static const char __pyx_k_Address_get_hostname[] = "Address.get_hostname"; static const char __pyx_k_Address_get_protocol[] = "Address.get_protocol"; static const char __pyx_k_Blob___reduce_cython[] = "_Blob.__reduce_cython__"; static const char __pyx_k_ServerBase_add_method[] = "_ServerBase.add_method"; static const char __pyx_k_ServerBase_del_method[] = "_ServerBase.del_method"; static const char __pyx_k_pyx_unpickle_Callback[] = "__pyx_unpickle_Callback"; static const char __pyx_k_weakref_method___call[] = "_weakref_method.__call__"; static const char __pyx_k_weakref_method___init[] = "_weakref_method.__init__"; static const char __pyx_k_Blob___setstate_cython[] = "_Blob.__setstate_cython__"; static const char __pyx_k_Bundle___reduce_cython[] = "Bundle.__reduce_cython__"; static const char __pyx_k_Server___reduce_cython[] = "Server.__reduce_cython__"; static const char __pyx_k_Address___reduce_cython[] = "Address.__reduce_cython__"; static const char __pyx_k_Message___reduce_cython[] = "Message.__reduce_cython__"; static const char __pyx_k_ServerBase_get_protocol[] = "_ServerBase.get_protocol"; static const char __pyx_k_unknown_OSC_data_type_c[] = "unknown OSC data type '%c'"; static const char __pyx_k_Bundle___setstate_cython[] = "Bundle.__setstate_cython__"; static const char __pyx_k_Callback___reduce_cython[] = "Callback.__reduce_cython__"; static const char __pyx_k_Server___setstate_cython[] = "Server.__setstate_cython__"; static const char __pyx_k_Address___setstate_cython[] = "Address.__setstate_cython__"; static const char __pyx_k_Message___setstate_cython[] = "Message.__setstate_cython__"; static const char __pyx_k_Callback___setstate_cython[] = "Callback.__setstate_cython__"; static const char __pyx_k_ServerBase___reduce_cython[] = "_ServerBase.__reduce_cython__"; static const char __pyx_k_ServerBase_register_methods[] = "_ServerBase.register_methods"; static const char __pyx_k_ServerBase___setstate_cython[] = "_ServerBase.__setstate_cython__"; static const char __pyx_k_ServerThread___reduce_cython[] = "ServerThread.__reduce_cython__"; static const char __pyx_k_path_must_be_a_string_or_None[] = "path must be a string or None"; static const char __pyx_k_ServerBase_add_bundle_handlers[] = "_ServerBase.add_bundle_handlers"; static const char __pyx_k_ServerThread___setstate_cython[] = "ServerThread.__setstate_cython__"; static const char __pyx_k_not_understood_expected_one_of[] = " not understood, expected one of 'UDP', 'TCP' or 'UNIX'"; static const char __pyx_k_register_methods_locals_lambda[] = "register_methods.."; static const char __pyx_k_A_decorator_that_serves_as_a_mo[] = "\n A decorator that serves as a more convenient alternative to [Server.add_method](#add_method).\n\n Args:\n path (str | None): the message path to be handled by the registered method.\n `None` may be used as a wildcard to match any OSC message.\n types (str): the argument types to be handled by the registered method.\n `None` may be used as a wildcard to match any OSC message.\n user_data: An arbitrary object that will be passed on to the decorated\n method every time a matching message is received.\n\n "; static const char __pyx_k_Raised_when_creating_a_liblo_OS[] = "\n Raised when creating a liblo OSC server fails.\n "; static const char __pyx_k_Raised_when_trying_to_create_an[] = "\n Raised when trying to create an invalid `Address` object.\n "; static const char __pyx_k_Server_method_called_after_free[] = "Server method called after free()"; static const char __pyx_k_Weak_reference_to_a_function_in[] = "\n Weak reference to a function, including support for bound methods.\n "; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))"; static const char __pyx_k_self__address_cannot_be_converte[] = "self._address cannot be converted to a Python object for pickling"; static const char __pyx_k_self__blob_cannot_be_converted_t[] = "self._blob cannot be converted to a Python object for pickling"; static const char __pyx_k_self__bundle_cannot_be_converted[] = "self._bundle cannot be converted to a Python object for pickling"; static const char __pyx_k_self__message_cannot_be_converte[] = "self._message cannot be converted to a Python object for pickling"; static const char __pyx_k_self__server_cannot_be_converted[] = "self._server cannot be converted to a Python object for pickling"; static const char __pyx_k_self__server_self__server_thread[] = "self._server,self._server_thread cannot be converted to a Python object for pickling"; static const char __pyx_k_typespec_must_be_a_string_or_Non[] = "typespec must be a string or None"; static const char __pyx_k_unsupported_message_argument_typ[] = "unsupported message argument type"; /* #### Code section: decls ### */ static PyObject *__pyx_pf_8pyliblo3_6_liblo__protostr_to_int(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_proto); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_15_weakref_method___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_f); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_15_weakref_method_2func(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_15_weakref_method_4__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6struct___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_kwargs); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_8Callback___init__(struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_user_data); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_8Callback_2__reduce_cython__(struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_8Callback_4__setstate_cython__(struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_2time(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_4send(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_target, PyObject *__pyx_v_args); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11ServerError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_num, PyObject *__pyx_v_msg, PyObject *__pyx_v_where); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11ServerError_2__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11make_method___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_types, PyObject *__pyx_v_user_data); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11make_method_2__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_f); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_11_ServerBase___init__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_reg_methods); /* proto */ static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_2register_methods(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_obj); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_4get_url(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_6get_port(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_8get_protocol(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_10fileno(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_12add_method(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_typespec, PyObject *__pyx_v_func, PyObject *__pyx_v_user_data); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_14del_method(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_typespec); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_16add_bundle_handlers(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_start_handler, PyObject *__pyx_v_end_handler, PyObject *__pyx_v_user_data); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_18send(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_target, PyObject *__pyx_v_args); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_3url___get__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_4port___get__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_8protocol___get__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_20__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_22__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_6Server___init__(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self, PyObject *__pyx_v_port, PyObject *__pyx_v_proto, PyObject *__pyx_v_reg_methods); /* proto */ static void __pyx_pf_8pyliblo3_6_liblo_6Server_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Server_4free(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Server_6recv(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self, PyObject *__pyx_v_timeout); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Server_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Server_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_12ServerThread___init__(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self, PyObject *__pyx_v_port, PyObject *__pyx_v_proto, PyObject *__pyx_v_reg_methods); /* proto */ static void __pyx_pf_8pyliblo3_6_liblo_12ServerThread_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_4free(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_6start(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_8stop(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_12AddressError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_12AddressError_2__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_7Address___init__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self, PyObject *__pyx_v_addr, PyObject *__pyx_v_addr2, PyObject *__pyx_v_proto); /* proto */ static void __pyx_pf_8pyliblo3_6_liblo_7Address_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_4get_url(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_6get_hostname(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_8get_port(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_10get_protocol(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_3url___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_8hostname___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_4port___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_8protocol___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_5_Blob___init__(struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self, PyObject *__pyx_v_arr); /* proto */ static void __pyx_pf_8pyliblo3_6_liblo_5_Blob_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_5_Blob_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_5_Blob_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_7Message___init__(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_args); /* proto */ static void __pyx_pf_8pyliblo3_6_liblo_7Message_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Message_4add(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_args); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Message_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Message_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_8pyliblo3_6_liblo_6Bundle___init__(struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self, PyObject *__pyx_v_messages); /* proto */ static void __pyx_pf_8pyliblo3_6_liblo_6Bundle_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Bundle_4add(struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self, PyObject *__pyx_v_args); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Bundle_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Bundle_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_6__pyx_unpickle_Callback(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_8pyliblo3_6_liblo_Callback(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_8pyliblo3_6_liblo__ServerBase(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Address(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Message(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Bundle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Server(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_ServerThread(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_8pyliblo3_6_liblo__Blob(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static __Pyx_CachedCFunction __pyx_umethod_PyBytes_Type_isdigit = {0, 0, 0, 0, 0}; /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ typedef struct { PyObject *__pyx_d; PyObject *__pyx_b; PyObject *__pyx_cython_runtime; PyObject *__pyx_empty_tuple; PyObject *__pyx_empty_bytes; PyObject *__pyx_empty_unicode; #ifdef __Pyx_CyFunction_USED PyTypeObject *__pyx_CyFunctionType; #endif #ifdef __Pyx_FusedFunction_USED PyTypeObject *__pyx_FusedFunctionType; #endif #ifdef __Pyx_Generator_USED PyTypeObject *__pyx_GeneratorType; #endif #ifdef __Pyx_IterableCoroutine_USED PyTypeObject *__pyx_IterableCoroutineType; #endif #ifdef __Pyx_Coroutine_USED PyTypeObject *__pyx_CoroutineAwaitType; #endif #ifdef __Pyx_Coroutine_USED PyTypeObject *__pyx_CoroutineType; #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif PyTypeObject *__pyx_ptype_7cpython_4type_type; #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif PyTypeObject *__pyx_ptype_7cpython_4bool_bool; #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif PyTypeObject *__pyx_ptype_7cpython_7complex_complex; #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE PyObject *__pyx_type_8pyliblo3_6_liblo_Callback; PyObject *__pyx_type_8pyliblo3_6_liblo__ServerBase; PyObject *__pyx_type_8pyliblo3_6_liblo_Address; PyObject *__pyx_type_8pyliblo3_6_liblo_Message; PyObject *__pyx_type_8pyliblo3_6_liblo_Bundle; PyObject *__pyx_type_8pyliblo3_6_liblo_Server; PyObject *__pyx_type_8pyliblo3_6_liblo_ServerThread; PyObject *__pyx_type_8pyliblo3_6_liblo__Blob; #endif PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo_Callback; PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo__ServerBase; PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo_Address; PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo_Message; PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo_Bundle; PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo_Server; PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo_ServerThread; PyTypeObject *__pyx_ptype_8pyliblo3_6_liblo__Blob; PyObject *__pyx_kp_s_0_16_1; PyObject *__pyx_kp_s_A_decorator_that_serves_as_a_mo; PyObject *__pyx_n_s_Address; PyObject *__pyx_n_s_AddressError; PyObject *__pyx_n_s_AddressError___init; PyObject *__pyx_n_s_AddressError___str; PyObject *__pyx_n_s_Address___reduce_cython; PyObject *__pyx_n_s_Address___setstate_cython; PyObject *__pyx_n_s_Address_get_hostname; PyObject *__pyx_n_s_Address_get_port; PyObject *__pyx_n_s_Address_get_protocol; PyObject *__pyx_n_s_Address_get_url; PyObject *__pyx_n_s_Blob; PyObject *__pyx_n_s_Blob___reduce_cython; PyObject *__pyx_n_s_Blob___setstate_cython; PyObject *__pyx_n_s_Bundle; PyObject *__pyx_n_s_Bundle___reduce_cython; PyObject *__pyx_n_s_Bundle___setstate_cython; PyObject *__pyx_n_s_Bundle_add; PyObject *__pyx_n_s_Callback; PyObject *__pyx_n_s_Callback___reduce_cython; PyObject *__pyx_n_s_Callback___setstate_cython; PyObject *__pyx_n_s_IOError; PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; PyObject *__pyx_n_s_Message; PyObject *__pyx_n_s_Message___reduce_cython; PyObject *__pyx_n_s_Message___setstate_cython; PyObject *__pyx_n_s_Message_add; PyObject *__pyx_n_s_OverflowError; PyObject *__pyx_n_s_PickleError; PyObject *__pyx_kp_u_Proto; PyObject *__pyx_kp_s_Raised_when_creating_a_liblo_OS; PyObject *__pyx_kp_s_Raised_when_trying_to_create_an; PyObject *__pyx_n_s_RuntimeError; PyObject *__pyx_n_s_Server; PyObject *__pyx_n_s_ServerBase; PyObject *__pyx_n_s_ServerBase___reduce_cython; PyObject *__pyx_n_s_ServerBase___setstate_cython; PyObject *__pyx_n_s_ServerBase_add_bundle_handlers; PyObject *__pyx_n_s_ServerBase_add_method; PyObject *__pyx_n_s_ServerBase_del_method; PyObject *__pyx_n_s_ServerBase_fileno; PyObject *__pyx_n_s_ServerBase_get_port; PyObject *__pyx_n_s_ServerBase_get_protocol; PyObject *__pyx_n_s_ServerBase_get_url; PyObject *__pyx_n_s_ServerBase_register_methods; PyObject *__pyx_n_s_ServerBase_send; PyObject *__pyx_n_s_ServerError; PyObject *__pyx_n_s_ServerError___init; PyObject *__pyx_n_s_ServerError___str; PyObject *__pyx_n_s_ServerThread; PyObject *__pyx_n_s_ServerThread___reduce_cython; PyObject *__pyx_n_s_ServerThread___setstate_cython; PyObject *__pyx_n_s_ServerThread_free; PyObject *__pyx_n_s_ServerThread_start; PyObject *__pyx_n_s_ServerThread_stop; PyObject *__pyx_n_s_Server___reduce_cython; PyObject *__pyx_n_s_Server___setstate_cython; PyObject *__pyx_n_s_Server_free; PyObject *__pyx_kp_s_Server_method_called_after_free; PyObject *__pyx_n_s_Server_recv; PyObject *__pyx_n_s_TCP; PyObject *__pyx_n_s_TypeError; PyObject *__pyx_n_s_UDP; PyObject *__pyx_n_s_UNIX; PyObject *__pyx_n_s_ValueError; PyObject *__pyx_kp_s_Weak_reference_to_a_function_in; PyObject *__pyx_kp_u__11; PyObject *__pyx_n_s__12; PyObject *__pyx_n_s__88; PyObject *__pyx_n_s_add; PyObject *__pyx_n_s_add_bundle_handlers; PyObject *__pyx_n_s_add_method; PyObject *__pyx_n_s_addr; PyObject *__pyx_n_s_addr2; PyObject *__pyx_kp_s_address_error_s; PyObject *__pyx_n_s_append; PyObject *__pyx_n_s_arg; PyObject *__pyx_n_s_args; PyObject *__pyx_n_s_arr; PyObject *__pyx_n_s_asyncio_coroutines; PyObject *__pyx_n_s_b; PyObject *__pyx_kp_s_blob_is_empty; PyObject *__pyx_n_s_call; PyObject *__pyx_n_s_cb; PyObject *__pyx_n_s_cb_data; PyObject *__pyx_n_s_chr; PyObject *__pyx_n_s_class; PyObject *__pyx_n_s_cline_in_traceback; PyObject *__pyx_n_s_counter; PyObject *__pyx_n_s_counter_2; PyObject *__pyx_n_s_decode; PyObject *__pyx_n_s_del_method; PyObject *__pyx_n_s_dict; PyObject *__pyx_n_s_dict_2; PyObject *__pyx_kp_u_disable; PyObject *__pyx_n_s_doc; PyObject *__pyx_n_s_e; PyObject *__pyx_kp_u_enable; PyObject *__pyx_n_s_encode; PyObject *__pyx_n_s_end_func; PyObject *__pyx_n_s_end_handler; PyObject *__pyx_n_s_exception; PyObject *__pyx_n_s_f; PyObject *__pyx_n_s_fileno; PyObject *__pyx_n_s_free; PyObject *__pyx_n_s_func; PyObject *__pyx_n_s_func_2; PyObject *__pyx_n_s_func_3; PyObject *__pyx_kp_u_gc; PyObject *__pyx_n_s_get; PyObject *__pyx_n_s_get_hostname; PyObject *__pyx_n_s_get_port; PyObject *__pyx_n_s_get_protocol; PyObject *__pyx_n_s_get_url; PyObject *__pyx_n_s_getfullargspec; PyObject *__pyx_n_s_getmembers; PyObject *__pyx_n_s_getstate; PyObject *__pyx_n_s_import; PyObject *__pyx_kp_s_in_s; PyObject *__pyx_n_s_inf; PyObject *__pyx_n_s_init; PyObject *__pyx_n_s_init_subclass; PyObject *__pyx_n_s_initializing; PyObject *__pyx_n_s_inspect; PyObject *__pyx_n_s_inspect_2; PyObject *__pyx_kp_s_invalid_URL_s; PyObject *__pyx_kp_s_invalid_protocol; PyObject *__pyx_kp_s_invalid_timetag; PyObject *__pyx_n_s_is_coroutine; PyObject *__pyx_n_s_isdigit; PyObject *__pyx_kp_u_isenabled; PyObject *__pyx_n_s_ismethod; PyObject *__pyx_n_s_items; PyObject *__pyx_n_s_k; PyObject *__pyx_n_s_key; PyObject *__pyx_n_s_kwargs; PyObject *__pyx_n_s_m; PyObject *__pyx_n_s_main; PyObject *__pyx_n_s_make_method; PyObject *__pyx_n_s_make_method___call; PyObject *__pyx_n_s_make_method___init; PyObject *__pyx_n_s_message; PyObject *__pyx_n_s_messages; PyObject *__pyx_n_s_metaclass; PyObject *__pyx_n_s_method_spec; PyObject *__pyx_n_s_methods; PyObject *__pyx_n_s_module; PyObject *__pyx_n_s_mro_entries; PyObject *__pyx_n_s_msg; PyObject *__pyx_n_s_name; PyObject *__pyx_n_s_name_2; PyObject *__pyx_n_s_new; PyObject *__pyx_kp_u_not_understood_expected_one_of; PyObject *__pyx_n_s_num; PyObject *__pyx_n_s_obj; PyObject *__pyx_n_s_p; PyObject *__pyx_n_s_path; PyObject *__pyx_kp_s_path_must_be_a_string_or_None; PyObject *__pyx_n_s_pickle; PyObject *__pyx_n_s_port; PyObject *__pyx_n_s_prepare; PyObject *__pyx_n_s_property; PyObject *__pyx_n_s_proto; PyObject *__pyx_n_s_protostr_to_int; PyObject *__pyx_n_s_pyliblo3__liblo; PyObject *__pyx_kp_s_pyliblo3__liblo_pyx; 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_Callback; PyObject *__pyx_n_s_pyx_vtable; PyObject *__pyx_n_s_qualname; PyObject *__pyx_n_s_r; PyObject *__pyx_n_s_recv; PyObject *__pyx_n_s_reduce; PyObject *__pyx_n_s_reduce_cython; PyObject *__pyx_n_s_reduce_ex; PyObject *__pyx_n_s_ref; PyObject *__pyx_n_s_reg_methods; PyObject *__pyx_n_s_register_methods; PyObject *__pyx_n_s_register_methods_locals_lambda; PyObject *__pyx_kp_s_s; PyObject *__pyx_n_s_s2; PyObject *__pyx_n_s_s_2; PyObject *__pyx_n_s_self; PyObject *__pyx_n_s_self_2; PyObject *__pyx_kp_s_self__address_cannot_be_converte; PyObject *__pyx_kp_s_self__blob_cannot_be_converted_t; PyObject *__pyx_kp_s_self__bundle_cannot_be_converted; PyObject *__pyx_kp_s_self__message_cannot_be_converte; PyObject *__pyx_kp_s_self__server_cannot_be_converted; PyObject *__pyx_kp_s_self__server_self__server_thread; PyObject *__pyx_n_s_send; PyObject *__pyx_kp_s_sending_failed_s; PyObject *__pyx_kp_s_server_error_d; PyObject *__pyx_n_s_set_name; PyObject *__pyx_n_s_setstate; PyObject *__pyx_n_s_setstate_cython; PyObject *__pyx_n_s_slots; PyObject *__pyx_n_s_sort; PyObject *__pyx_n_s_spec; PyObject *__pyx_n_s_spec_2; PyObject *__pyx_n_s_start; PyObject *__pyx_n_s_start_func; PyObject *__pyx_n_s_start_handler; PyObject *__pyx_n_s_state; PyObject *__pyx_n_s_stop; PyObject *__pyx_n_s_str; PyObject *__pyx_kp_s_stringsource; PyObject *__pyx_n_s_struct; PyObject *__pyx_n_s_struct___init; PyObject *__pyx_n_s_super; PyObject *__pyx_n_s_t; PyObject *__pyx_n_s_target; PyObject *__pyx_n_s_test; PyObject *__pyx_n_s_time; PyObject *__pyx_n_s_timeout; PyObject *__pyx_n_s_tmp; PyObject *__pyx_n_s_tt; PyObject *__pyx_n_s_types; PyObject *__pyx_n_s_typespec; PyObject *__pyx_kp_s_typespec_must_be_a_string_or_Non; PyObject *__pyx_kp_s_unknown_OSC_data_type_c; PyObject *__pyx_kp_s_unsupported_message_argument_typ; PyObject *__pyx_n_s_update; PyObject *__pyx_n_s_use_setstate; PyObject *__pyx_n_s_user_data; PyObject *__pyx_n_s_v; PyObject *__pyx_n_s_varargs; PyObject *__pyx_n_s_version; PyObject *__pyx_n_s_weakref; PyObject *__pyx_n_s_weakref_2; PyObject *__pyx_n_s_weakref_method; PyObject *__pyx_n_s_weakref_method___call; PyObject *__pyx_n_s_weakref_method___init; PyObject *__pyx_n_s_weakref_method_func; PyObject *__pyx_n_s_where; PyObject *__pyx_n_s_x; PyObject *__pyx_int_0; PyObject *__pyx_int_1; PyObject *__pyx_int_50507834; PyObject *__pyx_int_130844544; PyObject *__pyx_int_194199092; PyObject *__pyx_k__4; PyObject *__pyx_k__5; PyObject *__pyx_k__6; PyObject *__pyx_tuple_; PyObject *__pyx_tuple__2; PyObject *__pyx_tuple__3; PyObject *__pyx_tuple__7; PyObject *__pyx_tuple__8; PyObject *__pyx_tuple__9; PyObject *__pyx_tuple__10; PyObject *__pyx_tuple__13; PyObject *__pyx_tuple__15; PyObject *__pyx_tuple__16; PyObject *__pyx_tuple__18; PyObject *__pyx_tuple__20; PyObject *__pyx_tuple__22; PyObject *__pyx_tuple__24; PyObject *__pyx_tuple__26; PyObject *__pyx_tuple__28; PyObject *__pyx_tuple__30; PyObject *__pyx_tuple__32; PyObject *__pyx_tuple__34; PyObject *__pyx_tuple__36; PyObject *__pyx_tuple__38; PyObject *__pyx_tuple__40; PyObject *__pyx_tuple__42; PyObject *__pyx_tuple__47; PyObject *__pyx_tuple__49; PyObject *__pyx_tuple__51; PyObject *__pyx_tuple__53; PyObject *__pyx_tuple__58; PyObject *__pyx_tuple__67; PyObject *__pyx_tuple__78; PyObject *__pyx_tuple__82; PyObject *__pyx_tuple__86; PyObject *__pyx_codeobj__14; PyObject *__pyx_codeobj__17; PyObject *__pyx_codeobj__19; PyObject *__pyx_codeobj__21; PyObject *__pyx_codeobj__23; PyObject *__pyx_codeobj__25; PyObject *__pyx_codeobj__27; PyObject *__pyx_codeobj__29; PyObject *__pyx_codeobj__31; PyObject *__pyx_codeobj__33; 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__46; PyObject *__pyx_codeobj__48; PyObject *__pyx_codeobj__50; PyObject *__pyx_codeobj__52; PyObject *__pyx_codeobj__54; PyObject *__pyx_codeobj__55; PyObject *__pyx_codeobj__56; PyObject *__pyx_codeobj__57; PyObject *__pyx_codeobj__59; PyObject *__pyx_codeobj__60; PyObject *__pyx_codeobj__61; PyObject *__pyx_codeobj__62; PyObject *__pyx_codeobj__63; PyObject *__pyx_codeobj__64; PyObject *__pyx_codeobj__65; PyObject *__pyx_codeobj__66; PyObject *__pyx_codeobj__68; PyObject *__pyx_codeobj__69; PyObject *__pyx_codeobj__70; PyObject *__pyx_codeobj__71; PyObject *__pyx_codeobj__72; PyObject *__pyx_codeobj__73; PyObject *__pyx_codeobj__74; PyObject *__pyx_codeobj__75; PyObject *__pyx_codeobj__76; PyObject *__pyx_codeobj__77; PyObject *__pyx_codeobj__79; PyObject *__pyx_codeobj__80; PyObject *__pyx_codeobj__81; PyObject *__pyx_codeobj__83; PyObject *__pyx_codeobj__84; PyObject *__pyx_codeobj__85; PyObject *__pyx_codeobj__87; } __pyx_mstate; #if CYTHON_USE_MODULE_STATE #ifdef __cplusplus namespace { extern struct PyModuleDef __pyx_moduledef; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; #endif #define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) #define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) #define __pyx_m (PyState_FindModule(&__pyx_moduledef)) #else static __pyx_mstate __pyx_mstate_global_static = #ifdef __cplusplus {}; #else {0}; #endif static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; #endif /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_clear(PyObject *m) { __pyx_mstate *clear_module_state = __pyx_mstate(m); if (!clear_module_state) return 0; Py_CLEAR(clear_module_state->__pyx_d); Py_CLEAR(clear_module_state->__pyx_b); Py_CLEAR(clear_module_state->__pyx_cython_runtime); Py_CLEAR(clear_module_state->__pyx_empty_tuple); Py_CLEAR(clear_module_state->__pyx_empty_bytes); Py_CLEAR(clear_module_state->__pyx_empty_unicode); #ifdef __Pyx_CyFunction_USED Py_CLEAR(clear_module_state->__pyx_CyFunctionType); #endif #ifdef __Pyx_FusedFunction_USED Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); #endif Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4bool_bool); Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_7complex_complex); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo_Callback); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo_Callback); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo__ServerBase); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo__ServerBase); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo_Address); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo_Address); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo_Message); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo_Message); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo_Bundle); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo_Bundle); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo_Server); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo_Server); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo_ServerThread); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo_ServerThread); Py_CLEAR(clear_module_state->__pyx_ptype_8pyliblo3_6_liblo__Blob); Py_CLEAR(clear_module_state->__pyx_type_8pyliblo3_6_liblo__Blob); Py_CLEAR(clear_module_state->__pyx_kp_s_0_16_1); Py_CLEAR(clear_module_state->__pyx_kp_s_A_decorator_that_serves_as_a_mo); Py_CLEAR(clear_module_state->__pyx_n_s_Address); Py_CLEAR(clear_module_state->__pyx_n_s_AddressError); Py_CLEAR(clear_module_state->__pyx_n_s_AddressError___init); Py_CLEAR(clear_module_state->__pyx_n_s_AddressError___str); Py_CLEAR(clear_module_state->__pyx_n_s_Address___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Address___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Address_get_hostname); Py_CLEAR(clear_module_state->__pyx_n_s_Address_get_port); Py_CLEAR(clear_module_state->__pyx_n_s_Address_get_protocol); Py_CLEAR(clear_module_state->__pyx_n_s_Address_get_url); Py_CLEAR(clear_module_state->__pyx_n_s_Blob); Py_CLEAR(clear_module_state->__pyx_n_s_Blob___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Blob___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Bundle); Py_CLEAR(clear_module_state->__pyx_n_s_Bundle___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Bundle___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Bundle_add); Py_CLEAR(clear_module_state->__pyx_n_s_Callback); Py_CLEAR(clear_module_state->__pyx_n_s_Callback___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Callback___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_IOError); Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); Py_CLEAR(clear_module_state->__pyx_n_s_Message); Py_CLEAR(clear_module_state->__pyx_n_s_Message___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Message___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Message_add); Py_CLEAR(clear_module_state->__pyx_n_s_OverflowError); Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); Py_CLEAR(clear_module_state->__pyx_kp_u_Proto); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_when_creating_a_liblo_OS); Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_when_trying_to_create_an); Py_CLEAR(clear_module_state->__pyx_n_s_RuntimeError); Py_CLEAR(clear_module_state->__pyx_n_s_Server); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_add_bundle_handlers); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_add_method); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_del_method); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_fileno); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_get_port); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_get_protocol); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_get_url); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_register_methods); Py_CLEAR(clear_module_state->__pyx_n_s_ServerBase_send); Py_CLEAR(clear_module_state->__pyx_n_s_ServerError); Py_CLEAR(clear_module_state->__pyx_n_s_ServerError___init); Py_CLEAR(clear_module_state->__pyx_n_s_ServerError___str); Py_CLEAR(clear_module_state->__pyx_n_s_ServerThread); Py_CLEAR(clear_module_state->__pyx_n_s_ServerThread___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_ServerThread___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_ServerThread_free); Py_CLEAR(clear_module_state->__pyx_n_s_ServerThread_start); Py_CLEAR(clear_module_state->__pyx_n_s_ServerThread_stop); Py_CLEAR(clear_module_state->__pyx_n_s_Server___reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Server___setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_Server_free); Py_CLEAR(clear_module_state->__pyx_kp_s_Server_method_called_after_free); Py_CLEAR(clear_module_state->__pyx_n_s_Server_recv); Py_CLEAR(clear_module_state->__pyx_n_s_TCP); Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); Py_CLEAR(clear_module_state->__pyx_n_s_UDP); Py_CLEAR(clear_module_state->__pyx_n_s_UNIX); Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); Py_CLEAR(clear_module_state->__pyx_kp_s_Weak_reference_to_a_function_in); Py_CLEAR(clear_module_state->__pyx_kp_u__11); Py_CLEAR(clear_module_state->__pyx_n_s__12); Py_CLEAR(clear_module_state->__pyx_n_s__88); Py_CLEAR(clear_module_state->__pyx_n_s_add); Py_CLEAR(clear_module_state->__pyx_n_s_add_bundle_handlers); Py_CLEAR(clear_module_state->__pyx_n_s_add_method); Py_CLEAR(clear_module_state->__pyx_n_s_addr); Py_CLEAR(clear_module_state->__pyx_n_s_addr2); Py_CLEAR(clear_module_state->__pyx_kp_s_address_error_s); Py_CLEAR(clear_module_state->__pyx_n_s_append); Py_CLEAR(clear_module_state->__pyx_n_s_arg); Py_CLEAR(clear_module_state->__pyx_n_s_args); Py_CLEAR(clear_module_state->__pyx_n_s_arr); Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); Py_CLEAR(clear_module_state->__pyx_n_s_b); Py_CLEAR(clear_module_state->__pyx_kp_s_blob_is_empty); Py_CLEAR(clear_module_state->__pyx_n_s_call); Py_CLEAR(clear_module_state->__pyx_n_s_cb); Py_CLEAR(clear_module_state->__pyx_n_s_cb_data); Py_CLEAR(clear_module_state->__pyx_n_s_chr); Py_CLEAR(clear_module_state->__pyx_n_s_class); Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); Py_CLEAR(clear_module_state->__pyx_n_s_counter); Py_CLEAR(clear_module_state->__pyx_n_s_counter_2); Py_CLEAR(clear_module_state->__pyx_n_s_decode); Py_CLEAR(clear_module_state->__pyx_n_s_del_method); 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_n_s_doc); Py_CLEAR(clear_module_state->__pyx_n_s_e); Py_CLEAR(clear_module_state->__pyx_kp_u_enable); Py_CLEAR(clear_module_state->__pyx_n_s_encode); Py_CLEAR(clear_module_state->__pyx_n_s_end_func); Py_CLEAR(clear_module_state->__pyx_n_s_end_handler); Py_CLEAR(clear_module_state->__pyx_n_s_exception); Py_CLEAR(clear_module_state->__pyx_n_s_f); Py_CLEAR(clear_module_state->__pyx_n_s_fileno); Py_CLEAR(clear_module_state->__pyx_n_s_free); Py_CLEAR(clear_module_state->__pyx_n_s_func); Py_CLEAR(clear_module_state->__pyx_n_s_func_2); Py_CLEAR(clear_module_state->__pyx_n_s_func_3); Py_CLEAR(clear_module_state->__pyx_kp_u_gc); Py_CLEAR(clear_module_state->__pyx_n_s_get); Py_CLEAR(clear_module_state->__pyx_n_s_get_hostname); Py_CLEAR(clear_module_state->__pyx_n_s_get_port); Py_CLEAR(clear_module_state->__pyx_n_s_get_protocol); Py_CLEAR(clear_module_state->__pyx_n_s_get_url); Py_CLEAR(clear_module_state->__pyx_n_s_getfullargspec); Py_CLEAR(clear_module_state->__pyx_n_s_getmembers); Py_CLEAR(clear_module_state->__pyx_n_s_getstate); Py_CLEAR(clear_module_state->__pyx_n_s_import); Py_CLEAR(clear_module_state->__pyx_kp_s_in_s); Py_CLEAR(clear_module_state->__pyx_n_s_inf); Py_CLEAR(clear_module_state->__pyx_n_s_init); Py_CLEAR(clear_module_state->__pyx_n_s_init_subclass); Py_CLEAR(clear_module_state->__pyx_n_s_initializing); Py_CLEAR(clear_module_state->__pyx_n_s_inspect); Py_CLEAR(clear_module_state->__pyx_n_s_inspect_2); Py_CLEAR(clear_module_state->__pyx_kp_s_invalid_URL_s); Py_CLEAR(clear_module_state->__pyx_kp_s_invalid_protocol); Py_CLEAR(clear_module_state->__pyx_kp_s_invalid_timetag); Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); Py_CLEAR(clear_module_state->__pyx_n_s_isdigit); Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); Py_CLEAR(clear_module_state->__pyx_n_s_ismethod); Py_CLEAR(clear_module_state->__pyx_n_s_items); Py_CLEAR(clear_module_state->__pyx_n_s_k); Py_CLEAR(clear_module_state->__pyx_n_s_key); Py_CLEAR(clear_module_state->__pyx_n_s_kwargs); Py_CLEAR(clear_module_state->__pyx_n_s_m); Py_CLEAR(clear_module_state->__pyx_n_s_main); Py_CLEAR(clear_module_state->__pyx_n_s_make_method); Py_CLEAR(clear_module_state->__pyx_n_s_make_method___call); Py_CLEAR(clear_module_state->__pyx_n_s_make_method___init); Py_CLEAR(clear_module_state->__pyx_n_s_message); Py_CLEAR(clear_module_state->__pyx_n_s_messages); Py_CLEAR(clear_module_state->__pyx_n_s_metaclass); Py_CLEAR(clear_module_state->__pyx_n_s_method_spec); Py_CLEAR(clear_module_state->__pyx_n_s_methods); 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_msg); Py_CLEAR(clear_module_state->__pyx_n_s_name); Py_CLEAR(clear_module_state->__pyx_n_s_name_2); Py_CLEAR(clear_module_state->__pyx_n_s_new); Py_CLEAR(clear_module_state->__pyx_kp_u_not_understood_expected_one_of); Py_CLEAR(clear_module_state->__pyx_n_s_num); Py_CLEAR(clear_module_state->__pyx_n_s_obj); Py_CLEAR(clear_module_state->__pyx_n_s_p); Py_CLEAR(clear_module_state->__pyx_n_s_path); Py_CLEAR(clear_module_state->__pyx_kp_s_path_must_be_a_string_or_None); Py_CLEAR(clear_module_state->__pyx_n_s_pickle); Py_CLEAR(clear_module_state->__pyx_n_s_port); Py_CLEAR(clear_module_state->__pyx_n_s_prepare); Py_CLEAR(clear_module_state->__pyx_n_s_property); Py_CLEAR(clear_module_state->__pyx_n_s_proto); Py_CLEAR(clear_module_state->__pyx_n_s_protostr_to_int); Py_CLEAR(clear_module_state->__pyx_n_s_pyliblo3__liblo); Py_CLEAR(clear_module_state->__pyx_kp_s_pyliblo3__liblo_pyx); 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_Callback); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); Py_CLEAR(clear_module_state->__pyx_n_s_qualname); Py_CLEAR(clear_module_state->__pyx_n_s_r); Py_CLEAR(clear_module_state->__pyx_n_s_recv); 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_ref); Py_CLEAR(clear_module_state->__pyx_n_s_reg_methods); Py_CLEAR(clear_module_state->__pyx_n_s_register_methods); Py_CLEAR(clear_module_state->__pyx_n_s_register_methods_locals_lambda); Py_CLEAR(clear_module_state->__pyx_kp_s_s); Py_CLEAR(clear_module_state->__pyx_n_s_s2); Py_CLEAR(clear_module_state->__pyx_n_s_s_2); Py_CLEAR(clear_module_state->__pyx_n_s_self); Py_CLEAR(clear_module_state->__pyx_n_s_self_2); Py_CLEAR(clear_module_state->__pyx_kp_s_self__address_cannot_be_converte); Py_CLEAR(clear_module_state->__pyx_kp_s_self__blob_cannot_be_converted_t); Py_CLEAR(clear_module_state->__pyx_kp_s_self__bundle_cannot_be_converted); Py_CLEAR(clear_module_state->__pyx_kp_s_self__message_cannot_be_converte); Py_CLEAR(clear_module_state->__pyx_kp_s_self__server_cannot_be_converted); Py_CLEAR(clear_module_state->__pyx_kp_s_self__server_self__server_thread); Py_CLEAR(clear_module_state->__pyx_n_s_send); Py_CLEAR(clear_module_state->__pyx_kp_s_sending_failed_s); Py_CLEAR(clear_module_state->__pyx_kp_s_server_error_d); Py_CLEAR(clear_module_state->__pyx_n_s_set_name); 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_slots); Py_CLEAR(clear_module_state->__pyx_n_s_sort); Py_CLEAR(clear_module_state->__pyx_n_s_spec); Py_CLEAR(clear_module_state->__pyx_n_s_spec_2); Py_CLEAR(clear_module_state->__pyx_n_s_start); Py_CLEAR(clear_module_state->__pyx_n_s_start_func); Py_CLEAR(clear_module_state->__pyx_n_s_start_handler); Py_CLEAR(clear_module_state->__pyx_n_s_state); Py_CLEAR(clear_module_state->__pyx_n_s_stop); 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_struct); Py_CLEAR(clear_module_state->__pyx_n_s_struct___init); Py_CLEAR(clear_module_state->__pyx_n_s_super); Py_CLEAR(clear_module_state->__pyx_n_s_t); Py_CLEAR(clear_module_state->__pyx_n_s_target); Py_CLEAR(clear_module_state->__pyx_n_s_test); Py_CLEAR(clear_module_state->__pyx_n_s_time); Py_CLEAR(clear_module_state->__pyx_n_s_timeout); Py_CLEAR(clear_module_state->__pyx_n_s_tmp); Py_CLEAR(clear_module_state->__pyx_n_s_tt); Py_CLEAR(clear_module_state->__pyx_n_s_types); Py_CLEAR(clear_module_state->__pyx_n_s_typespec); Py_CLEAR(clear_module_state->__pyx_kp_s_typespec_must_be_a_string_or_Non); Py_CLEAR(clear_module_state->__pyx_kp_s_unknown_OSC_data_type_c); Py_CLEAR(clear_module_state->__pyx_kp_s_unsupported_message_argument_typ); Py_CLEAR(clear_module_state->__pyx_n_s_update); Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); Py_CLEAR(clear_module_state->__pyx_n_s_user_data); Py_CLEAR(clear_module_state->__pyx_n_s_v); Py_CLEAR(clear_module_state->__pyx_n_s_varargs); Py_CLEAR(clear_module_state->__pyx_n_s_version); Py_CLEAR(clear_module_state->__pyx_n_s_weakref); Py_CLEAR(clear_module_state->__pyx_n_s_weakref_2); Py_CLEAR(clear_module_state->__pyx_n_s_weakref_method); Py_CLEAR(clear_module_state->__pyx_n_s_weakref_method___call); Py_CLEAR(clear_module_state->__pyx_n_s_weakref_method___init); Py_CLEAR(clear_module_state->__pyx_n_s_weakref_method_func); Py_CLEAR(clear_module_state->__pyx_n_s_where); Py_CLEAR(clear_module_state->__pyx_n_s_x); Py_CLEAR(clear_module_state->__pyx_int_0); Py_CLEAR(clear_module_state->__pyx_int_1); Py_CLEAR(clear_module_state->__pyx_int_50507834); Py_CLEAR(clear_module_state->__pyx_int_130844544); Py_CLEAR(clear_module_state->__pyx_int_194199092); Py_CLEAR(clear_module_state->__pyx_k__4); Py_CLEAR(clear_module_state->__pyx_k__5); Py_CLEAR(clear_module_state->__pyx_k__6); Py_CLEAR(clear_module_state->__pyx_tuple_); Py_CLEAR(clear_module_state->__pyx_tuple__2); Py_CLEAR(clear_module_state->__pyx_tuple__3); Py_CLEAR(clear_module_state->__pyx_tuple__7); Py_CLEAR(clear_module_state->__pyx_tuple__8); Py_CLEAR(clear_module_state->__pyx_tuple__9); Py_CLEAR(clear_module_state->__pyx_tuple__10); Py_CLEAR(clear_module_state->__pyx_tuple__13); Py_CLEAR(clear_module_state->__pyx_tuple__15); 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__24); 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__34); 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__47); Py_CLEAR(clear_module_state->__pyx_tuple__49); Py_CLEAR(clear_module_state->__pyx_tuple__51); Py_CLEAR(clear_module_state->__pyx_tuple__53); Py_CLEAR(clear_module_state->__pyx_tuple__58); Py_CLEAR(clear_module_state->__pyx_tuple__67); Py_CLEAR(clear_module_state->__pyx_tuple__78); Py_CLEAR(clear_module_state->__pyx_tuple__82); Py_CLEAR(clear_module_state->__pyx_tuple__86); Py_CLEAR(clear_module_state->__pyx_codeobj__14); 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__23); Py_CLEAR(clear_module_state->__pyx_codeobj__25); Py_CLEAR(clear_module_state->__pyx_codeobj__27); Py_CLEAR(clear_module_state->__pyx_codeobj__29); Py_CLEAR(clear_module_state->__pyx_codeobj__31); Py_CLEAR(clear_module_state->__pyx_codeobj__33); Py_CLEAR(clear_module_state->__pyx_codeobj__35); Py_CLEAR(clear_module_state->__pyx_codeobj__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__46); Py_CLEAR(clear_module_state->__pyx_codeobj__48); Py_CLEAR(clear_module_state->__pyx_codeobj__50); Py_CLEAR(clear_module_state->__pyx_codeobj__52); Py_CLEAR(clear_module_state->__pyx_codeobj__54); Py_CLEAR(clear_module_state->__pyx_codeobj__55); 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__60); Py_CLEAR(clear_module_state->__pyx_codeobj__61); Py_CLEAR(clear_module_state->__pyx_codeobj__62); Py_CLEAR(clear_module_state->__pyx_codeobj__63); Py_CLEAR(clear_module_state->__pyx_codeobj__64); Py_CLEAR(clear_module_state->__pyx_codeobj__65); Py_CLEAR(clear_module_state->__pyx_codeobj__66); Py_CLEAR(clear_module_state->__pyx_codeobj__68); Py_CLEAR(clear_module_state->__pyx_codeobj__69); Py_CLEAR(clear_module_state->__pyx_codeobj__70); Py_CLEAR(clear_module_state->__pyx_codeobj__71); Py_CLEAR(clear_module_state->__pyx_codeobj__72); Py_CLEAR(clear_module_state->__pyx_codeobj__73); Py_CLEAR(clear_module_state->__pyx_codeobj__74); Py_CLEAR(clear_module_state->__pyx_codeobj__75); Py_CLEAR(clear_module_state->__pyx_codeobj__76); Py_CLEAR(clear_module_state->__pyx_codeobj__77); Py_CLEAR(clear_module_state->__pyx_codeobj__79); Py_CLEAR(clear_module_state->__pyx_codeobj__80); Py_CLEAR(clear_module_state->__pyx_codeobj__81); Py_CLEAR(clear_module_state->__pyx_codeobj__83); Py_CLEAR(clear_module_state->__pyx_codeobj__84); Py_CLEAR(clear_module_state->__pyx_codeobj__85); Py_CLEAR(clear_module_state->__pyx_codeobj__87); return 0; } #endif /* #### Code section: module_state_traverse ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { __pyx_mstate *traverse_module_state = __pyx_mstate(m); if (!traverse_module_state) return 0; Py_VISIT(traverse_module_state->__pyx_d); Py_VISIT(traverse_module_state->__pyx_b); Py_VISIT(traverse_module_state->__pyx_cython_runtime); Py_VISIT(traverse_module_state->__pyx_empty_tuple); Py_VISIT(traverse_module_state->__pyx_empty_bytes); Py_VISIT(traverse_module_state->__pyx_empty_unicode); #ifdef __Pyx_CyFunction_USED Py_VISIT(traverse_module_state->__pyx_CyFunctionType); #endif #ifdef __Pyx_FusedFunction_USED Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); #endif Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4bool_bool); Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_7complex_complex); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo_Callback); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo_Callback); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo__ServerBase); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo__ServerBase); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo_Address); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo_Address); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo_Message); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo_Message); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo_Bundle); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo_Bundle); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo_Server); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo_Server); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo_ServerThread); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo_ServerThread); Py_VISIT(traverse_module_state->__pyx_ptype_8pyliblo3_6_liblo__Blob); Py_VISIT(traverse_module_state->__pyx_type_8pyliblo3_6_liblo__Blob); Py_VISIT(traverse_module_state->__pyx_kp_s_0_16_1); Py_VISIT(traverse_module_state->__pyx_kp_s_A_decorator_that_serves_as_a_mo); Py_VISIT(traverse_module_state->__pyx_n_s_Address); Py_VISIT(traverse_module_state->__pyx_n_s_AddressError); Py_VISIT(traverse_module_state->__pyx_n_s_AddressError___init); Py_VISIT(traverse_module_state->__pyx_n_s_AddressError___str); Py_VISIT(traverse_module_state->__pyx_n_s_Address___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Address___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Address_get_hostname); Py_VISIT(traverse_module_state->__pyx_n_s_Address_get_port); Py_VISIT(traverse_module_state->__pyx_n_s_Address_get_protocol); Py_VISIT(traverse_module_state->__pyx_n_s_Address_get_url); Py_VISIT(traverse_module_state->__pyx_n_s_Blob); Py_VISIT(traverse_module_state->__pyx_n_s_Blob___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Blob___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Bundle); Py_VISIT(traverse_module_state->__pyx_n_s_Bundle___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Bundle___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Bundle_add); Py_VISIT(traverse_module_state->__pyx_n_s_Callback); Py_VISIT(traverse_module_state->__pyx_n_s_Callback___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Callback___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_IOError); Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); Py_VISIT(traverse_module_state->__pyx_n_s_Message); Py_VISIT(traverse_module_state->__pyx_n_s_Message___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Message___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Message_add); Py_VISIT(traverse_module_state->__pyx_n_s_OverflowError); Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); Py_VISIT(traverse_module_state->__pyx_kp_u_Proto); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_when_creating_a_liblo_OS); Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_when_trying_to_create_an); Py_VISIT(traverse_module_state->__pyx_n_s_RuntimeError); Py_VISIT(traverse_module_state->__pyx_n_s_Server); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_add_bundle_handlers); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_add_method); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_del_method); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_fileno); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_get_port); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_get_protocol); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_get_url); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_register_methods); Py_VISIT(traverse_module_state->__pyx_n_s_ServerBase_send); Py_VISIT(traverse_module_state->__pyx_n_s_ServerError); Py_VISIT(traverse_module_state->__pyx_n_s_ServerError___init); Py_VISIT(traverse_module_state->__pyx_n_s_ServerError___str); Py_VISIT(traverse_module_state->__pyx_n_s_ServerThread); Py_VISIT(traverse_module_state->__pyx_n_s_ServerThread___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_ServerThread___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_ServerThread_free); Py_VISIT(traverse_module_state->__pyx_n_s_ServerThread_start); Py_VISIT(traverse_module_state->__pyx_n_s_ServerThread_stop); Py_VISIT(traverse_module_state->__pyx_n_s_Server___reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Server___setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_Server_free); Py_VISIT(traverse_module_state->__pyx_kp_s_Server_method_called_after_free); Py_VISIT(traverse_module_state->__pyx_n_s_Server_recv); Py_VISIT(traverse_module_state->__pyx_n_s_TCP); Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); Py_VISIT(traverse_module_state->__pyx_n_s_UDP); Py_VISIT(traverse_module_state->__pyx_n_s_UNIX); Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); Py_VISIT(traverse_module_state->__pyx_kp_s_Weak_reference_to_a_function_in); Py_VISIT(traverse_module_state->__pyx_kp_u__11); Py_VISIT(traverse_module_state->__pyx_n_s__12); Py_VISIT(traverse_module_state->__pyx_n_s__88); Py_VISIT(traverse_module_state->__pyx_n_s_add); Py_VISIT(traverse_module_state->__pyx_n_s_add_bundle_handlers); Py_VISIT(traverse_module_state->__pyx_n_s_add_method); Py_VISIT(traverse_module_state->__pyx_n_s_addr); Py_VISIT(traverse_module_state->__pyx_n_s_addr2); Py_VISIT(traverse_module_state->__pyx_kp_s_address_error_s); Py_VISIT(traverse_module_state->__pyx_n_s_append); Py_VISIT(traverse_module_state->__pyx_n_s_arg); Py_VISIT(traverse_module_state->__pyx_n_s_args); Py_VISIT(traverse_module_state->__pyx_n_s_arr); Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); Py_VISIT(traverse_module_state->__pyx_n_s_b); Py_VISIT(traverse_module_state->__pyx_kp_s_blob_is_empty); Py_VISIT(traverse_module_state->__pyx_n_s_call); Py_VISIT(traverse_module_state->__pyx_n_s_cb); Py_VISIT(traverse_module_state->__pyx_n_s_cb_data); Py_VISIT(traverse_module_state->__pyx_n_s_chr); Py_VISIT(traverse_module_state->__pyx_n_s_class); Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); Py_VISIT(traverse_module_state->__pyx_n_s_counter); Py_VISIT(traverse_module_state->__pyx_n_s_counter_2); Py_VISIT(traverse_module_state->__pyx_n_s_decode); Py_VISIT(traverse_module_state->__pyx_n_s_del_method); 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_n_s_doc); Py_VISIT(traverse_module_state->__pyx_n_s_e); Py_VISIT(traverse_module_state->__pyx_kp_u_enable); Py_VISIT(traverse_module_state->__pyx_n_s_encode); Py_VISIT(traverse_module_state->__pyx_n_s_end_func); Py_VISIT(traverse_module_state->__pyx_n_s_end_handler); Py_VISIT(traverse_module_state->__pyx_n_s_exception); Py_VISIT(traverse_module_state->__pyx_n_s_f); Py_VISIT(traverse_module_state->__pyx_n_s_fileno); Py_VISIT(traverse_module_state->__pyx_n_s_free); Py_VISIT(traverse_module_state->__pyx_n_s_func); Py_VISIT(traverse_module_state->__pyx_n_s_func_2); Py_VISIT(traverse_module_state->__pyx_n_s_func_3); Py_VISIT(traverse_module_state->__pyx_kp_u_gc); Py_VISIT(traverse_module_state->__pyx_n_s_get); Py_VISIT(traverse_module_state->__pyx_n_s_get_hostname); Py_VISIT(traverse_module_state->__pyx_n_s_get_port); Py_VISIT(traverse_module_state->__pyx_n_s_get_protocol); Py_VISIT(traverse_module_state->__pyx_n_s_get_url); Py_VISIT(traverse_module_state->__pyx_n_s_getfullargspec); Py_VISIT(traverse_module_state->__pyx_n_s_getmembers); Py_VISIT(traverse_module_state->__pyx_n_s_getstate); Py_VISIT(traverse_module_state->__pyx_n_s_import); Py_VISIT(traverse_module_state->__pyx_kp_s_in_s); Py_VISIT(traverse_module_state->__pyx_n_s_inf); Py_VISIT(traverse_module_state->__pyx_n_s_init); Py_VISIT(traverse_module_state->__pyx_n_s_init_subclass); Py_VISIT(traverse_module_state->__pyx_n_s_initializing); Py_VISIT(traverse_module_state->__pyx_n_s_inspect); Py_VISIT(traverse_module_state->__pyx_n_s_inspect_2); Py_VISIT(traverse_module_state->__pyx_kp_s_invalid_URL_s); Py_VISIT(traverse_module_state->__pyx_kp_s_invalid_protocol); Py_VISIT(traverse_module_state->__pyx_kp_s_invalid_timetag); Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); Py_VISIT(traverse_module_state->__pyx_n_s_isdigit); Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); Py_VISIT(traverse_module_state->__pyx_n_s_ismethod); Py_VISIT(traverse_module_state->__pyx_n_s_items); Py_VISIT(traverse_module_state->__pyx_n_s_k); Py_VISIT(traverse_module_state->__pyx_n_s_key); Py_VISIT(traverse_module_state->__pyx_n_s_kwargs); Py_VISIT(traverse_module_state->__pyx_n_s_m); Py_VISIT(traverse_module_state->__pyx_n_s_main); Py_VISIT(traverse_module_state->__pyx_n_s_make_method); Py_VISIT(traverse_module_state->__pyx_n_s_make_method___call); Py_VISIT(traverse_module_state->__pyx_n_s_make_method___init); Py_VISIT(traverse_module_state->__pyx_n_s_message); Py_VISIT(traverse_module_state->__pyx_n_s_messages); Py_VISIT(traverse_module_state->__pyx_n_s_metaclass); Py_VISIT(traverse_module_state->__pyx_n_s_method_spec); Py_VISIT(traverse_module_state->__pyx_n_s_methods); 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_msg); Py_VISIT(traverse_module_state->__pyx_n_s_name); Py_VISIT(traverse_module_state->__pyx_n_s_name_2); Py_VISIT(traverse_module_state->__pyx_n_s_new); Py_VISIT(traverse_module_state->__pyx_kp_u_not_understood_expected_one_of); Py_VISIT(traverse_module_state->__pyx_n_s_num); Py_VISIT(traverse_module_state->__pyx_n_s_obj); Py_VISIT(traverse_module_state->__pyx_n_s_p); Py_VISIT(traverse_module_state->__pyx_n_s_path); Py_VISIT(traverse_module_state->__pyx_kp_s_path_must_be_a_string_or_None); Py_VISIT(traverse_module_state->__pyx_n_s_pickle); Py_VISIT(traverse_module_state->__pyx_n_s_port); Py_VISIT(traverse_module_state->__pyx_n_s_prepare); Py_VISIT(traverse_module_state->__pyx_n_s_property); Py_VISIT(traverse_module_state->__pyx_n_s_proto); Py_VISIT(traverse_module_state->__pyx_n_s_protostr_to_int); Py_VISIT(traverse_module_state->__pyx_n_s_pyliblo3__liblo); Py_VISIT(traverse_module_state->__pyx_kp_s_pyliblo3__liblo_pyx); 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_Callback); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); Py_VISIT(traverse_module_state->__pyx_n_s_qualname); Py_VISIT(traverse_module_state->__pyx_n_s_r); Py_VISIT(traverse_module_state->__pyx_n_s_recv); 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_ref); Py_VISIT(traverse_module_state->__pyx_n_s_reg_methods); Py_VISIT(traverse_module_state->__pyx_n_s_register_methods); Py_VISIT(traverse_module_state->__pyx_n_s_register_methods_locals_lambda); Py_VISIT(traverse_module_state->__pyx_kp_s_s); Py_VISIT(traverse_module_state->__pyx_n_s_s2); Py_VISIT(traverse_module_state->__pyx_n_s_s_2); Py_VISIT(traverse_module_state->__pyx_n_s_self); Py_VISIT(traverse_module_state->__pyx_n_s_self_2); Py_VISIT(traverse_module_state->__pyx_kp_s_self__address_cannot_be_converte); Py_VISIT(traverse_module_state->__pyx_kp_s_self__blob_cannot_be_converted_t); Py_VISIT(traverse_module_state->__pyx_kp_s_self__bundle_cannot_be_converted); Py_VISIT(traverse_module_state->__pyx_kp_s_self__message_cannot_be_converte); Py_VISIT(traverse_module_state->__pyx_kp_s_self__server_cannot_be_converted); Py_VISIT(traverse_module_state->__pyx_kp_s_self__server_self__server_thread); Py_VISIT(traverse_module_state->__pyx_n_s_send); Py_VISIT(traverse_module_state->__pyx_kp_s_sending_failed_s); Py_VISIT(traverse_module_state->__pyx_kp_s_server_error_d); Py_VISIT(traverse_module_state->__pyx_n_s_set_name); 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_slots); Py_VISIT(traverse_module_state->__pyx_n_s_sort); Py_VISIT(traverse_module_state->__pyx_n_s_spec); Py_VISIT(traverse_module_state->__pyx_n_s_spec_2); Py_VISIT(traverse_module_state->__pyx_n_s_start); Py_VISIT(traverse_module_state->__pyx_n_s_start_func); Py_VISIT(traverse_module_state->__pyx_n_s_start_handler); Py_VISIT(traverse_module_state->__pyx_n_s_state); Py_VISIT(traverse_module_state->__pyx_n_s_stop); 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_struct); Py_VISIT(traverse_module_state->__pyx_n_s_struct___init); Py_VISIT(traverse_module_state->__pyx_n_s_super); Py_VISIT(traverse_module_state->__pyx_n_s_t); Py_VISIT(traverse_module_state->__pyx_n_s_target); Py_VISIT(traverse_module_state->__pyx_n_s_test); Py_VISIT(traverse_module_state->__pyx_n_s_time); Py_VISIT(traverse_module_state->__pyx_n_s_timeout); Py_VISIT(traverse_module_state->__pyx_n_s_tmp); Py_VISIT(traverse_module_state->__pyx_n_s_tt); Py_VISIT(traverse_module_state->__pyx_n_s_types); Py_VISIT(traverse_module_state->__pyx_n_s_typespec); Py_VISIT(traverse_module_state->__pyx_kp_s_typespec_must_be_a_string_or_Non); Py_VISIT(traverse_module_state->__pyx_kp_s_unknown_OSC_data_type_c); Py_VISIT(traverse_module_state->__pyx_kp_s_unsupported_message_argument_typ); Py_VISIT(traverse_module_state->__pyx_n_s_update); Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); Py_VISIT(traverse_module_state->__pyx_n_s_user_data); Py_VISIT(traverse_module_state->__pyx_n_s_v); Py_VISIT(traverse_module_state->__pyx_n_s_varargs); Py_VISIT(traverse_module_state->__pyx_n_s_version); Py_VISIT(traverse_module_state->__pyx_n_s_weakref); Py_VISIT(traverse_module_state->__pyx_n_s_weakref_2); Py_VISIT(traverse_module_state->__pyx_n_s_weakref_method); Py_VISIT(traverse_module_state->__pyx_n_s_weakref_method___call); Py_VISIT(traverse_module_state->__pyx_n_s_weakref_method___init); Py_VISIT(traverse_module_state->__pyx_n_s_weakref_method_func); Py_VISIT(traverse_module_state->__pyx_n_s_where); Py_VISIT(traverse_module_state->__pyx_n_s_x); Py_VISIT(traverse_module_state->__pyx_int_0); Py_VISIT(traverse_module_state->__pyx_int_1); Py_VISIT(traverse_module_state->__pyx_int_50507834); Py_VISIT(traverse_module_state->__pyx_int_130844544); Py_VISIT(traverse_module_state->__pyx_int_194199092); Py_VISIT(traverse_module_state->__pyx_k__4); Py_VISIT(traverse_module_state->__pyx_k__5); Py_VISIT(traverse_module_state->__pyx_k__6); Py_VISIT(traverse_module_state->__pyx_tuple_); Py_VISIT(traverse_module_state->__pyx_tuple__2); Py_VISIT(traverse_module_state->__pyx_tuple__3); Py_VISIT(traverse_module_state->__pyx_tuple__7); Py_VISIT(traverse_module_state->__pyx_tuple__8); Py_VISIT(traverse_module_state->__pyx_tuple__9); Py_VISIT(traverse_module_state->__pyx_tuple__10); Py_VISIT(traverse_module_state->__pyx_tuple__13); Py_VISIT(traverse_module_state->__pyx_tuple__15); 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__24); 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__34); 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__47); Py_VISIT(traverse_module_state->__pyx_tuple__49); Py_VISIT(traverse_module_state->__pyx_tuple__51); Py_VISIT(traverse_module_state->__pyx_tuple__53); Py_VISIT(traverse_module_state->__pyx_tuple__58); Py_VISIT(traverse_module_state->__pyx_tuple__67); Py_VISIT(traverse_module_state->__pyx_tuple__78); Py_VISIT(traverse_module_state->__pyx_tuple__82); Py_VISIT(traverse_module_state->__pyx_tuple__86); Py_VISIT(traverse_module_state->__pyx_codeobj__14); 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__23); Py_VISIT(traverse_module_state->__pyx_codeobj__25); Py_VISIT(traverse_module_state->__pyx_codeobj__27); Py_VISIT(traverse_module_state->__pyx_codeobj__29); Py_VISIT(traverse_module_state->__pyx_codeobj__31); Py_VISIT(traverse_module_state->__pyx_codeobj__33); Py_VISIT(traverse_module_state->__pyx_codeobj__35); Py_VISIT(traverse_module_state->__pyx_codeobj__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__46); Py_VISIT(traverse_module_state->__pyx_codeobj__48); Py_VISIT(traverse_module_state->__pyx_codeobj__50); Py_VISIT(traverse_module_state->__pyx_codeobj__52); Py_VISIT(traverse_module_state->__pyx_codeobj__54); Py_VISIT(traverse_module_state->__pyx_codeobj__55); 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__60); Py_VISIT(traverse_module_state->__pyx_codeobj__61); Py_VISIT(traverse_module_state->__pyx_codeobj__62); Py_VISIT(traverse_module_state->__pyx_codeobj__63); Py_VISIT(traverse_module_state->__pyx_codeobj__64); Py_VISIT(traverse_module_state->__pyx_codeobj__65); Py_VISIT(traverse_module_state->__pyx_codeobj__66); Py_VISIT(traverse_module_state->__pyx_codeobj__68); Py_VISIT(traverse_module_state->__pyx_codeobj__69); Py_VISIT(traverse_module_state->__pyx_codeobj__70); Py_VISIT(traverse_module_state->__pyx_codeobj__71); Py_VISIT(traverse_module_state->__pyx_codeobj__72); Py_VISIT(traverse_module_state->__pyx_codeobj__73); Py_VISIT(traverse_module_state->__pyx_codeobj__74); Py_VISIT(traverse_module_state->__pyx_codeobj__75); Py_VISIT(traverse_module_state->__pyx_codeobj__76); Py_VISIT(traverse_module_state->__pyx_codeobj__77); Py_VISIT(traverse_module_state->__pyx_codeobj__79); Py_VISIT(traverse_module_state->__pyx_codeobj__80); Py_VISIT(traverse_module_state->__pyx_codeobj__81); Py_VISIT(traverse_module_state->__pyx_codeobj__83); Py_VISIT(traverse_module_state->__pyx_codeobj__84); Py_VISIT(traverse_module_state->__pyx_codeobj__85); Py_VISIT(traverse_module_state->__pyx_codeobj__87); 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_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #define __pyx_ptype_7cpython_4bool_bool __pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #define __pyx_ptype_7cpython_7complex_complex __pyx_mstate_global->__pyx_ptype_7cpython_7complex_complex #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #define __pyx_type_8pyliblo3_6_liblo_Callback __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo_Callback #define __pyx_type_8pyliblo3_6_liblo__ServerBase __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo__ServerBase #define __pyx_type_8pyliblo3_6_liblo_Address __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo_Address #define __pyx_type_8pyliblo3_6_liblo_Message __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo_Message #define __pyx_type_8pyliblo3_6_liblo_Bundle __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo_Bundle #define __pyx_type_8pyliblo3_6_liblo_Server __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo_Server #define __pyx_type_8pyliblo3_6_liblo_ServerThread __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo_ServerThread #define __pyx_type_8pyliblo3_6_liblo__Blob __pyx_mstate_global->__pyx_type_8pyliblo3_6_liblo__Blob #endif #define __pyx_ptype_8pyliblo3_6_liblo_Callback __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo_Callback #define __pyx_ptype_8pyliblo3_6_liblo__ServerBase __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo__ServerBase #define __pyx_ptype_8pyliblo3_6_liblo_Address __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo_Address #define __pyx_ptype_8pyliblo3_6_liblo_Message __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo_Message #define __pyx_ptype_8pyliblo3_6_liblo_Bundle __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo_Bundle #define __pyx_ptype_8pyliblo3_6_liblo_Server __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo_Server #define __pyx_ptype_8pyliblo3_6_liblo_ServerThread __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo_ServerThread #define __pyx_ptype_8pyliblo3_6_liblo__Blob __pyx_mstate_global->__pyx_ptype_8pyliblo3_6_liblo__Blob #define __pyx_kp_s_0_16_1 __pyx_mstate_global->__pyx_kp_s_0_16_1 #define __pyx_kp_s_A_decorator_that_serves_as_a_mo __pyx_mstate_global->__pyx_kp_s_A_decorator_that_serves_as_a_mo #define __pyx_n_s_Address __pyx_mstate_global->__pyx_n_s_Address #define __pyx_n_s_AddressError __pyx_mstate_global->__pyx_n_s_AddressError #define __pyx_n_s_AddressError___init __pyx_mstate_global->__pyx_n_s_AddressError___init #define __pyx_n_s_AddressError___str __pyx_mstate_global->__pyx_n_s_AddressError___str #define __pyx_n_s_Address___reduce_cython __pyx_mstate_global->__pyx_n_s_Address___reduce_cython #define __pyx_n_s_Address___setstate_cython __pyx_mstate_global->__pyx_n_s_Address___setstate_cython #define __pyx_n_s_Address_get_hostname __pyx_mstate_global->__pyx_n_s_Address_get_hostname #define __pyx_n_s_Address_get_port __pyx_mstate_global->__pyx_n_s_Address_get_port #define __pyx_n_s_Address_get_protocol __pyx_mstate_global->__pyx_n_s_Address_get_protocol #define __pyx_n_s_Address_get_url __pyx_mstate_global->__pyx_n_s_Address_get_url #define __pyx_n_s_Blob __pyx_mstate_global->__pyx_n_s_Blob #define __pyx_n_s_Blob___reduce_cython __pyx_mstate_global->__pyx_n_s_Blob___reduce_cython #define __pyx_n_s_Blob___setstate_cython __pyx_mstate_global->__pyx_n_s_Blob___setstate_cython #define __pyx_n_s_Bundle __pyx_mstate_global->__pyx_n_s_Bundle #define __pyx_n_s_Bundle___reduce_cython __pyx_mstate_global->__pyx_n_s_Bundle___reduce_cython #define __pyx_n_s_Bundle___setstate_cython __pyx_mstate_global->__pyx_n_s_Bundle___setstate_cython #define __pyx_n_s_Bundle_add __pyx_mstate_global->__pyx_n_s_Bundle_add #define __pyx_n_s_Callback __pyx_mstate_global->__pyx_n_s_Callback #define __pyx_n_s_Callback___reduce_cython __pyx_mstate_global->__pyx_n_s_Callback___reduce_cython #define __pyx_n_s_Callback___setstate_cython __pyx_mstate_global->__pyx_n_s_Callback___setstate_cython #define __pyx_n_s_IOError __pyx_mstate_global->__pyx_n_s_IOError #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_Message __pyx_mstate_global->__pyx_n_s_Message #define __pyx_n_s_Message___reduce_cython __pyx_mstate_global->__pyx_n_s_Message___reduce_cython #define __pyx_n_s_Message___setstate_cython __pyx_mstate_global->__pyx_n_s_Message___setstate_cython #define __pyx_n_s_Message_add __pyx_mstate_global->__pyx_n_s_Message_add #define __pyx_n_s_OverflowError __pyx_mstate_global->__pyx_n_s_OverflowError #define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError #define __pyx_kp_u_Proto __pyx_mstate_global->__pyx_kp_u_Proto #define __pyx_kp_s_Raised_when_creating_a_liblo_OS __pyx_mstate_global->__pyx_kp_s_Raised_when_creating_a_liblo_OS #define __pyx_kp_s_Raised_when_trying_to_create_an __pyx_mstate_global->__pyx_kp_s_Raised_when_trying_to_create_an #define __pyx_n_s_RuntimeError __pyx_mstate_global->__pyx_n_s_RuntimeError #define __pyx_n_s_Server __pyx_mstate_global->__pyx_n_s_Server #define __pyx_n_s_ServerBase __pyx_mstate_global->__pyx_n_s_ServerBase #define __pyx_n_s_ServerBase___reduce_cython __pyx_mstate_global->__pyx_n_s_ServerBase___reduce_cython #define __pyx_n_s_ServerBase___setstate_cython __pyx_mstate_global->__pyx_n_s_ServerBase___setstate_cython #define __pyx_n_s_ServerBase_add_bundle_handlers __pyx_mstate_global->__pyx_n_s_ServerBase_add_bundle_handlers #define __pyx_n_s_ServerBase_add_method __pyx_mstate_global->__pyx_n_s_ServerBase_add_method #define __pyx_n_s_ServerBase_del_method __pyx_mstate_global->__pyx_n_s_ServerBase_del_method #define __pyx_n_s_ServerBase_fileno __pyx_mstate_global->__pyx_n_s_ServerBase_fileno #define __pyx_n_s_ServerBase_get_port __pyx_mstate_global->__pyx_n_s_ServerBase_get_port #define __pyx_n_s_ServerBase_get_protocol __pyx_mstate_global->__pyx_n_s_ServerBase_get_protocol #define __pyx_n_s_ServerBase_get_url __pyx_mstate_global->__pyx_n_s_ServerBase_get_url #define __pyx_n_s_ServerBase_register_methods __pyx_mstate_global->__pyx_n_s_ServerBase_register_methods #define __pyx_n_s_ServerBase_send __pyx_mstate_global->__pyx_n_s_ServerBase_send #define __pyx_n_s_ServerError __pyx_mstate_global->__pyx_n_s_ServerError #define __pyx_n_s_ServerError___init __pyx_mstate_global->__pyx_n_s_ServerError___init #define __pyx_n_s_ServerError___str __pyx_mstate_global->__pyx_n_s_ServerError___str #define __pyx_n_s_ServerThread __pyx_mstate_global->__pyx_n_s_ServerThread #define __pyx_n_s_ServerThread___reduce_cython __pyx_mstate_global->__pyx_n_s_ServerThread___reduce_cython #define __pyx_n_s_ServerThread___setstate_cython __pyx_mstate_global->__pyx_n_s_ServerThread___setstate_cython #define __pyx_n_s_ServerThread_free __pyx_mstate_global->__pyx_n_s_ServerThread_free #define __pyx_n_s_ServerThread_start __pyx_mstate_global->__pyx_n_s_ServerThread_start #define __pyx_n_s_ServerThread_stop __pyx_mstate_global->__pyx_n_s_ServerThread_stop #define __pyx_n_s_Server___reduce_cython __pyx_mstate_global->__pyx_n_s_Server___reduce_cython #define __pyx_n_s_Server___setstate_cython __pyx_mstate_global->__pyx_n_s_Server___setstate_cython #define __pyx_n_s_Server_free __pyx_mstate_global->__pyx_n_s_Server_free #define __pyx_kp_s_Server_method_called_after_free __pyx_mstate_global->__pyx_kp_s_Server_method_called_after_free #define __pyx_n_s_Server_recv __pyx_mstate_global->__pyx_n_s_Server_recv #define __pyx_n_s_TCP __pyx_mstate_global->__pyx_n_s_TCP #define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError #define __pyx_n_s_UDP __pyx_mstate_global->__pyx_n_s_UDP #define __pyx_n_s_UNIX __pyx_mstate_global->__pyx_n_s_UNIX #define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError #define __pyx_kp_s_Weak_reference_to_a_function_in __pyx_mstate_global->__pyx_kp_s_Weak_reference_to_a_function_in #define __pyx_kp_u__11 __pyx_mstate_global->__pyx_kp_u__11 #define __pyx_n_s__12 __pyx_mstate_global->__pyx_n_s__12 #define __pyx_n_s__88 __pyx_mstate_global->__pyx_n_s__88 #define __pyx_n_s_add __pyx_mstate_global->__pyx_n_s_add #define __pyx_n_s_add_bundle_handlers __pyx_mstate_global->__pyx_n_s_add_bundle_handlers #define __pyx_n_s_add_method __pyx_mstate_global->__pyx_n_s_add_method #define __pyx_n_s_addr __pyx_mstate_global->__pyx_n_s_addr #define __pyx_n_s_addr2 __pyx_mstate_global->__pyx_n_s_addr2 #define __pyx_kp_s_address_error_s __pyx_mstate_global->__pyx_kp_s_address_error_s #define __pyx_n_s_append __pyx_mstate_global->__pyx_n_s_append #define __pyx_n_s_arg __pyx_mstate_global->__pyx_n_s_arg #define __pyx_n_s_args __pyx_mstate_global->__pyx_n_s_args #define __pyx_n_s_arr __pyx_mstate_global->__pyx_n_s_arr #define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines #define __pyx_n_s_b __pyx_mstate_global->__pyx_n_s_b #define __pyx_kp_s_blob_is_empty __pyx_mstate_global->__pyx_kp_s_blob_is_empty #define __pyx_n_s_call __pyx_mstate_global->__pyx_n_s_call #define __pyx_n_s_cb __pyx_mstate_global->__pyx_n_s_cb #define __pyx_n_s_cb_data __pyx_mstate_global->__pyx_n_s_cb_data #define __pyx_n_s_chr __pyx_mstate_global->__pyx_n_s_chr #define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class #define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback #define __pyx_n_s_counter __pyx_mstate_global->__pyx_n_s_counter #define __pyx_n_s_counter_2 __pyx_mstate_global->__pyx_n_s_counter_2 #define __pyx_n_s_decode __pyx_mstate_global->__pyx_n_s_decode #define __pyx_n_s_del_method __pyx_mstate_global->__pyx_n_s_del_method #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_n_s_doc __pyx_mstate_global->__pyx_n_s_doc #define __pyx_n_s_e __pyx_mstate_global->__pyx_n_s_e #define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable #define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode #define __pyx_n_s_end_func __pyx_mstate_global->__pyx_n_s_end_func #define __pyx_n_s_end_handler __pyx_mstate_global->__pyx_n_s_end_handler #define __pyx_n_s_exception __pyx_mstate_global->__pyx_n_s_exception #define __pyx_n_s_f __pyx_mstate_global->__pyx_n_s_f #define __pyx_n_s_fileno __pyx_mstate_global->__pyx_n_s_fileno #define __pyx_n_s_free __pyx_mstate_global->__pyx_n_s_free #define __pyx_n_s_func __pyx_mstate_global->__pyx_n_s_func #define __pyx_n_s_func_2 __pyx_mstate_global->__pyx_n_s_func_2 #define __pyx_n_s_func_3 __pyx_mstate_global->__pyx_n_s_func_3 #define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc #define __pyx_n_s_get __pyx_mstate_global->__pyx_n_s_get #define __pyx_n_s_get_hostname __pyx_mstate_global->__pyx_n_s_get_hostname #define __pyx_n_s_get_port __pyx_mstate_global->__pyx_n_s_get_port #define __pyx_n_s_get_protocol __pyx_mstate_global->__pyx_n_s_get_protocol #define __pyx_n_s_get_url __pyx_mstate_global->__pyx_n_s_get_url #define __pyx_n_s_getfullargspec __pyx_mstate_global->__pyx_n_s_getfullargspec #define __pyx_n_s_getmembers __pyx_mstate_global->__pyx_n_s_getmembers #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_kp_s_in_s __pyx_mstate_global->__pyx_kp_s_in_s #define __pyx_n_s_inf __pyx_mstate_global->__pyx_n_s_inf #define __pyx_n_s_init __pyx_mstate_global->__pyx_n_s_init #define __pyx_n_s_init_subclass __pyx_mstate_global->__pyx_n_s_init_subclass #define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing #define __pyx_n_s_inspect __pyx_mstate_global->__pyx_n_s_inspect #define __pyx_n_s_inspect_2 __pyx_mstate_global->__pyx_n_s_inspect_2 #define __pyx_kp_s_invalid_URL_s __pyx_mstate_global->__pyx_kp_s_invalid_URL_s #define __pyx_kp_s_invalid_protocol __pyx_mstate_global->__pyx_kp_s_invalid_protocol #define __pyx_kp_s_invalid_timetag __pyx_mstate_global->__pyx_kp_s_invalid_timetag #define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine #define __pyx_n_s_isdigit __pyx_mstate_global->__pyx_n_s_isdigit #define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled #define __pyx_n_s_ismethod __pyx_mstate_global->__pyx_n_s_ismethod #define __pyx_n_s_items __pyx_mstate_global->__pyx_n_s_items #define __pyx_n_s_k __pyx_mstate_global->__pyx_n_s_k #define __pyx_n_s_key __pyx_mstate_global->__pyx_n_s_key #define __pyx_n_s_kwargs __pyx_mstate_global->__pyx_n_s_kwargs #define __pyx_n_s_m __pyx_mstate_global->__pyx_n_s_m #define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main #define __pyx_n_s_make_method __pyx_mstate_global->__pyx_n_s_make_method #define __pyx_n_s_make_method___call __pyx_mstate_global->__pyx_n_s_make_method___call #define __pyx_n_s_make_method___init __pyx_mstate_global->__pyx_n_s_make_method___init #define __pyx_n_s_message __pyx_mstate_global->__pyx_n_s_message #define __pyx_n_s_messages __pyx_mstate_global->__pyx_n_s_messages #define __pyx_n_s_metaclass __pyx_mstate_global->__pyx_n_s_metaclass #define __pyx_n_s_method_spec __pyx_mstate_global->__pyx_n_s_method_spec #define __pyx_n_s_methods __pyx_mstate_global->__pyx_n_s_methods #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_msg __pyx_mstate_global->__pyx_n_s_msg #define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name #define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 #define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new #define __pyx_kp_u_not_understood_expected_one_of __pyx_mstate_global->__pyx_kp_u_not_understood_expected_one_of #define __pyx_n_s_num __pyx_mstate_global->__pyx_n_s_num #define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj #define __pyx_n_s_p __pyx_mstate_global->__pyx_n_s_p #define __pyx_n_s_path __pyx_mstate_global->__pyx_n_s_path #define __pyx_kp_s_path_must_be_a_string_or_None __pyx_mstate_global->__pyx_kp_s_path_must_be_a_string_or_None #define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle #define __pyx_n_s_port __pyx_mstate_global->__pyx_n_s_port #define __pyx_n_s_prepare __pyx_mstate_global->__pyx_n_s_prepare #define __pyx_n_s_property __pyx_mstate_global->__pyx_n_s_property #define __pyx_n_s_proto __pyx_mstate_global->__pyx_n_s_proto #define __pyx_n_s_protostr_to_int __pyx_mstate_global->__pyx_n_s_protostr_to_int #define __pyx_n_s_pyliblo3__liblo __pyx_mstate_global->__pyx_n_s_pyliblo3__liblo #define __pyx_kp_s_pyliblo3__liblo_pyx __pyx_mstate_global->__pyx_kp_s_pyliblo3__liblo_pyx #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_Callback __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Callback #define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable #define __pyx_n_s_qualname __pyx_mstate_global->__pyx_n_s_qualname #define __pyx_n_s_r __pyx_mstate_global->__pyx_n_s_r #define __pyx_n_s_recv __pyx_mstate_global->__pyx_n_s_recv #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_ref __pyx_mstate_global->__pyx_n_s_ref #define __pyx_n_s_reg_methods __pyx_mstate_global->__pyx_n_s_reg_methods #define __pyx_n_s_register_methods __pyx_mstate_global->__pyx_n_s_register_methods #define __pyx_n_s_register_methods_locals_lambda __pyx_mstate_global->__pyx_n_s_register_methods_locals_lambda #define __pyx_kp_s_s __pyx_mstate_global->__pyx_kp_s_s #define __pyx_n_s_s2 __pyx_mstate_global->__pyx_n_s_s2 #define __pyx_n_s_s_2 __pyx_mstate_global->__pyx_n_s_s_2 #define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self #define __pyx_n_s_self_2 __pyx_mstate_global->__pyx_n_s_self_2 #define __pyx_kp_s_self__address_cannot_be_converte __pyx_mstate_global->__pyx_kp_s_self__address_cannot_be_converte #define __pyx_kp_s_self__blob_cannot_be_converted_t __pyx_mstate_global->__pyx_kp_s_self__blob_cannot_be_converted_t #define __pyx_kp_s_self__bundle_cannot_be_converted __pyx_mstate_global->__pyx_kp_s_self__bundle_cannot_be_converted #define __pyx_kp_s_self__message_cannot_be_converte __pyx_mstate_global->__pyx_kp_s_self__message_cannot_be_converte #define __pyx_kp_s_self__server_cannot_be_converted __pyx_mstate_global->__pyx_kp_s_self__server_cannot_be_converted #define __pyx_kp_s_self__server_self__server_thread __pyx_mstate_global->__pyx_kp_s_self__server_self__server_thread #define __pyx_n_s_send __pyx_mstate_global->__pyx_n_s_send #define __pyx_kp_s_sending_failed_s __pyx_mstate_global->__pyx_kp_s_sending_failed_s #define __pyx_kp_s_server_error_d __pyx_mstate_global->__pyx_kp_s_server_error_d #define __pyx_n_s_set_name __pyx_mstate_global->__pyx_n_s_set_name #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_slots __pyx_mstate_global->__pyx_n_s_slots #define __pyx_n_s_sort __pyx_mstate_global->__pyx_n_s_sort #define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec #define __pyx_n_s_spec_2 __pyx_mstate_global->__pyx_n_s_spec_2 #define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start #define __pyx_n_s_start_func __pyx_mstate_global->__pyx_n_s_start_func #define __pyx_n_s_start_handler __pyx_mstate_global->__pyx_n_s_start_handler #define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state #define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop #define __pyx_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_struct __pyx_mstate_global->__pyx_n_s_struct #define __pyx_n_s_struct___init __pyx_mstate_global->__pyx_n_s_struct___init #define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super #define __pyx_n_s_t __pyx_mstate_global->__pyx_n_s_t #define __pyx_n_s_target __pyx_mstate_global->__pyx_n_s_target #define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test #define __pyx_n_s_time __pyx_mstate_global->__pyx_n_s_time #define __pyx_n_s_timeout __pyx_mstate_global->__pyx_n_s_timeout #define __pyx_n_s_tmp __pyx_mstate_global->__pyx_n_s_tmp #define __pyx_n_s_tt __pyx_mstate_global->__pyx_n_s_tt #define __pyx_n_s_types __pyx_mstate_global->__pyx_n_s_types #define __pyx_n_s_typespec __pyx_mstate_global->__pyx_n_s_typespec #define __pyx_kp_s_typespec_must_be_a_string_or_Non __pyx_mstate_global->__pyx_kp_s_typespec_must_be_a_string_or_Non #define __pyx_kp_s_unknown_OSC_data_type_c __pyx_mstate_global->__pyx_kp_s_unknown_OSC_data_type_c #define __pyx_kp_s_unsupported_message_argument_typ __pyx_mstate_global->__pyx_kp_s_unsupported_message_argument_typ #define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update #define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate #define __pyx_n_s_user_data __pyx_mstate_global->__pyx_n_s_user_data #define __pyx_n_s_v __pyx_mstate_global->__pyx_n_s_v #define __pyx_n_s_varargs __pyx_mstate_global->__pyx_n_s_varargs #define __pyx_n_s_version __pyx_mstate_global->__pyx_n_s_version #define __pyx_n_s_weakref __pyx_mstate_global->__pyx_n_s_weakref #define __pyx_n_s_weakref_2 __pyx_mstate_global->__pyx_n_s_weakref_2 #define __pyx_n_s_weakref_method __pyx_mstate_global->__pyx_n_s_weakref_method #define __pyx_n_s_weakref_method___call __pyx_mstate_global->__pyx_n_s_weakref_method___call #define __pyx_n_s_weakref_method___init __pyx_mstate_global->__pyx_n_s_weakref_method___init #define __pyx_n_s_weakref_method_func __pyx_mstate_global->__pyx_n_s_weakref_method_func #define __pyx_n_s_where __pyx_mstate_global->__pyx_n_s_where #define __pyx_n_s_x __pyx_mstate_global->__pyx_n_s_x #define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 #define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 #define __pyx_int_50507834 __pyx_mstate_global->__pyx_int_50507834 #define __pyx_int_130844544 __pyx_mstate_global->__pyx_int_130844544 #define __pyx_int_194199092 __pyx_mstate_global->__pyx_int_194199092 #define __pyx_k__4 __pyx_mstate_global->__pyx_k__4 #define __pyx_k__5 __pyx_mstate_global->__pyx_k__5 #define __pyx_k__6 __pyx_mstate_global->__pyx_k__6 #define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ #define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 #define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 #define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 #define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 #define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 #define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 #define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 #define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 #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__24 __pyx_mstate_global->__pyx_tuple__24 #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__34 __pyx_mstate_global->__pyx_tuple__34 #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__47 __pyx_mstate_global->__pyx_tuple__47 #define __pyx_tuple__49 __pyx_mstate_global->__pyx_tuple__49 #define __pyx_tuple__51 __pyx_mstate_global->__pyx_tuple__51 #define __pyx_tuple__53 __pyx_mstate_global->__pyx_tuple__53 #define __pyx_tuple__58 __pyx_mstate_global->__pyx_tuple__58 #define __pyx_tuple__67 __pyx_mstate_global->__pyx_tuple__67 #define __pyx_tuple__78 __pyx_mstate_global->__pyx_tuple__78 #define __pyx_tuple__82 __pyx_mstate_global->__pyx_tuple__82 #define __pyx_tuple__86 __pyx_mstate_global->__pyx_tuple__86 #define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 #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__23 __pyx_mstate_global->__pyx_codeobj__23 #define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25 #define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 #define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 #define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31 #define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 #define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 #define __pyx_codeobj__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__46 __pyx_mstate_global->__pyx_codeobj__46 #define __pyx_codeobj__48 __pyx_mstate_global->__pyx_codeobj__48 #define __pyx_codeobj__50 __pyx_mstate_global->__pyx_codeobj__50 #define __pyx_codeobj__52 __pyx_mstate_global->__pyx_codeobj__52 #define __pyx_codeobj__54 __pyx_mstate_global->__pyx_codeobj__54 #define __pyx_codeobj__55 __pyx_mstate_global->__pyx_codeobj__55 #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__60 __pyx_mstate_global->__pyx_codeobj__60 #define __pyx_codeobj__61 __pyx_mstate_global->__pyx_codeobj__61 #define __pyx_codeobj__62 __pyx_mstate_global->__pyx_codeobj__62 #define __pyx_codeobj__63 __pyx_mstate_global->__pyx_codeobj__63 #define __pyx_codeobj__64 __pyx_mstate_global->__pyx_codeobj__64 #define __pyx_codeobj__65 __pyx_mstate_global->__pyx_codeobj__65 #define __pyx_codeobj__66 __pyx_mstate_global->__pyx_codeobj__66 #define __pyx_codeobj__68 __pyx_mstate_global->__pyx_codeobj__68 #define __pyx_codeobj__69 __pyx_mstate_global->__pyx_codeobj__69 #define __pyx_codeobj__70 __pyx_mstate_global->__pyx_codeobj__70 #define __pyx_codeobj__71 __pyx_mstate_global->__pyx_codeobj__71 #define __pyx_codeobj__72 __pyx_mstate_global->__pyx_codeobj__72 #define __pyx_codeobj__73 __pyx_mstate_global->__pyx_codeobj__73 #define __pyx_codeobj__74 __pyx_mstate_global->__pyx_codeobj__74 #define __pyx_codeobj__75 __pyx_mstate_global->__pyx_codeobj__75 #define __pyx_codeobj__76 __pyx_mstate_global->__pyx_codeobj__76 #define __pyx_codeobj__77 __pyx_mstate_global->__pyx_codeobj__77 #define __pyx_codeobj__79 __pyx_mstate_global->__pyx_codeobj__79 #define __pyx_codeobj__80 __pyx_mstate_global->__pyx_codeobj__80 #define __pyx_codeobj__81 __pyx_mstate_global->__pyx_codeobj__81 #define __pyx_codeobj__83 __pyx_mstate_global->__pyx_codeobj__83 #define __pyx_codeobj__84 __pyx_mstate_global->__pyx_codeobj__84 #define __pyx_codeobj__85 __pyx_mstate_global->__pyx_codeobj__85 #define __pyx_codeobj__87 __pyx_mstate_global->__pyx_codeobj__87 /* #### Code section: module_code ### */ /* "cpython/complex.pxd":19 * * @property * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< * return self.cval.real * */ 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; /* "cpython/complex.pxd":19 * * @property * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< * return self.cval.real * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "cpython/complex.pxd":23 * * @property * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< * return self.cval.imag * */ 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_L0:; return __pyx_r; } /* "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; 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; } } /* "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 # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_pyvalue); __pyx_r = __pyx_v_pyvalue; goto __pyx_L0; /* "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, */ /* 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(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; } /* "pyliblo3/_liblo.pyx":34 * * * def _protostr_to_int(str proto): # <<<<<<<<<<<<<< * if proto == 'UDP': * return LO_UDP */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_1_protostr_to_int(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_8pyliblo3_6_liblo__protostr_to_int, "_protostr_to_int(str proto)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_1_protostr_to_int = {"_protostr_to_int", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_1_protostr_to_int, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo__protostr_to_int}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_1_protostr_to_int(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_proto = 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("_protostr_to_int (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_proto,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_proto)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 34, __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, "_protostr_to_int") < 0)) __PYX_ERR(0, 34, __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_proto = ((PyObject*)values[0]); } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_protostr_to_int", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 34, __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("pyliblo3._liblo._protostr_to_int", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_proto), (&PyString_Type), 1, "proto", 1))) __PYX_ERR(0, 34, __pyx_L1_error) __pyx_r = __pyx_pf_8pyliblo3_6_liblo__protostr_to_int(__pyx_self, __pyx_v_proto); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo__protostr_to_int(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_proto) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; Py_UCS4 __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_protostr_to_int", 1); /* "pyliblo3/_liblo.pyx":35 * * def _protostr_to_int(str proto): * if proto == 'UDP': # <<<<<<<<<<<<<< * return LO_UDP * elif proto == 'TCP': */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_proto, __pyx_n_s_UDP, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 35, __pyx_L1_error) if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":36 * def _protostr_to_int(str proto): * if proto == 'UDP': * return LO_UDP # <<<<<<<<<<<<<< * elif proto == 'TCP': * return LO_TCP */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LO_UDP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":35 * * def _protostr_to_int(str proto): * if proto == 'UDP': # <<<<<<<<<<<<<< * return LO_UDP * elif proto == 'TCP': */ } /* "pyliblo3/_liblo.pyx":37 * if proto == 'UDP': * return LO_UDP * elif proto == 'TCP': # <<<<<<<<<<<<<< * return LO_TCP * elif proto == 'UNIX': */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_proto, __pyx_n_s_TCP, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 37, __pyx_L1_error) if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":38 * return LO_UDP * elif proto == 'TCP': * return LO_TCP # <<<<<<<<<<<<<< * elif proto == 'UNIX': * return LO_UNIX */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LO_TCP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":37 * if proto == 'UDP': * return LO_UDP * elif proto == 'TCP': # <<<<<<<<<<<<<< * return LO_TCP * elif proto == 'UNIX': */ } /* "pyliblo3/_liblo.pyx":39 * elif proto == 'TCP': * return LO_TCP * elif proto == 'UNIX': # <<<<<<<<<<<<<< * return LO_UNIX * else: */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_proto, __pyx_n_s_UNIX, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 39, __pyx_L1_error) if (likely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":40 * return LO_TCP * elif proto == 'UNIX': * return LO_UNIX # <<<<<<<<<<<<<< * else: * raise ValueError(f"Proto {proto} not understood, expected one of 'UDP', 'TCP' or 'UNIX'") */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LO_UNIX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":39 * elif proto == 'TCP': * return LO_TCP * elif proto == 'UNIX': # <<<<<<<<<<<<<< * return LO_UNIX * else: */ } /* "pyliblo3/_liblo.pyx":42 * return LO_UNIX * else: * raise ValueError(f"Proto {proto} not understood, expected one of 'UDP', 'TCP' or 'UNIX'") # <<<<<<<<<<<<<< * * */ /*else*/ { __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = 127; __Pyx_INCREF(__pyx_kp_u_Proto); __pyx_t_3 += 6; __Pyx_GIVEREF(__pyx_kp_u_Proto); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_Proto); __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_proto, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_4) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_4; __pyx_t_3 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u_not_understood_expected_one_of); __pyx_t_3 += 55; __Pyx_GIVEREF(__pyx_kp_u_not_understood_expected_one_of); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_not_understood_expected_one_of); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 42, __pyx_L1_error) } /* "pyliblo3/_liblo.pyx":34 * * * def _protostr_to_int(str proto): # <<<<<<<<<<<<<< * if proto == 'UDP': * return LO_UDP */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyliblo3._liblo._protostr_to_int", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":51 * __slots__ = ('_func', 'obj') * * def __init__(self, f): # <<<<<<<<<<<<<< * if _inspect.ismethod(f): * self._func = f.__func__ */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_1__init__(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_8pyliblo3_6_liblo_15_weakref_method___init__, "_weakref_method.__init__(self, f)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_15_weakref_method_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_15_weakref_method___init__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_1__init__(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_self = 0; PyObject *__pyx_v_f = 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("__init__ (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_self,&__pyx_n_s_f,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_f)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 51, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 51, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_f = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 51, __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("pyliblo3._liblo._weakref_method.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_15_weakref_method___init__(__pyx_self, __pyx_v_self, __pyx_v_f); /* 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_8pyliblo3_6_liblo_15_weakref_method___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_f) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":52 * * def __init__(self, f): * if _inspect.ismethod(f): # <<<<<<<<<<<<<< * self._func = f.__func__ * self.obj = _weakref.ref(f.__self__) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_inspect); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ismethod); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_f}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_5) { /* "pyliblo3/_liblo.pyx":53 * def __init__(self, f): * if _inspect.ismethod(f): * self._func = f.__func__ # <<<<<<<<<<<<<< * self.obj = _weakref.ref(f.__self__) * else: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_func); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_func_2, __pyx_t_1) < 0) __PYX_ERR(0, 53, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":54 * if _inspect.ismethod(f): * self._func = f.__func__ * self.obj = _weakref.ref(f.__self__) # <<<<<<<<<<<<<< * else: * self._func = f */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_weakref); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_self_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_obj, __pyx_t_1) < 0) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":52 * * def __init__(self, f): * if _inspect.ismethod(f): # <<<<<<<<<<<<<< * self._func = f.__func__ * self.obj = _weakref.ref(f.__self__) */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":56 * self.obj = _weakref.ref(f.__self__) * else: * self._func = f # <<<<<<<<<<<<<< * self.obj = None * */ /*else*/ { if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_func_2, __pyx_v_f) < 0) __PYX_ERR(0, 56, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":57 * else: * self._func = f * self.obj = None # <<<<<<<<<<<<<< * * @property */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_obj, Py_None) < 0) __PYX_ERR(0, 57, __pyx_L1_error) } __pyx_L3:; /* "pyliblo3/_liblo.pyx":51 * __slots__ = ('_func', 'obj') * * def __init__(self, f): # <<<<<<<<<<<<<< * if _inspect.ismethod(f): * self._func = f.__func__ */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyliblo3._liblo._weakref_method.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":59 * self.obj = None * * @property # <<<<<<<<<<<<<< * def func(self): * if self.obj: */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_3func(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_8pyliblo3_6_liblo_15_weakref_method_2func, "_weakref_method.func(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_15_weakref_method_3func = {"func", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_3func, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_15_weakref_method_2func}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_3func(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_self = 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("func (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_self,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_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __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, "func") < 0)) __PYX_ERR(0, 59, __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_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("func", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 59, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("pyliblo3._liblo._weakref_method.func", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_15_weakref_method_2func(__pyx_self, __pyx_v_self); /* 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_8pyliblo3_6_liblo_15_weakref_method_2func(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("func", 1); /* "pyliblo3/_liblo.pyx":61 * @property * def func(self): * if self.obj: # <<<<<<<<<<<<<< * return self._func.__get__(self.obj(), self.obj().__class__) * else: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_obj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":62 * def func(self): * if self.obj: * return self._func.__get__(self.obj(), self.obj().__class__) # <<<<<<<<<<<<<< * else: * return self._func */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_func_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_obj); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; __pyx_t_3 = __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_3)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_obj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_class); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_6}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":61 * @property * def func(self): * if self.obj: # <<<<<<<<<<<<<< * return self._func.__get__(self.obj(), self.obj().__class__) * else: */ } /* "pyliblo3/_liblo.pyx":64 * return self._func.__get__(self.obj(), self.obj().__class__) * else: * return self._func # <<<<<<<<<<<<<< * * def __call__(self, *args, **kwargs): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_func_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; } /* "pyliblo3/_liblo.pyx":59 * self.obj = None * * @property # <<<<<<<<<<<<<< * def func(self): * if self.obj: */ /* 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_XDECREF(__pyx_t_8); __Pyx_AddTraceback("pyliblo3._liblo._weakref_method.func", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":66 * return self._func * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< * return self.func(*args, **kwargs) * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_5__call__(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_8pyliblo3_6_liblo_15_weakref_method_4__call__, "_weakref_method.__call__(self, *args, **kwargs)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_15_weakref_method_5__call__ = {"__call__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_5__call__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_15_weakref_method_4__call__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_15_weakref_method_5__call__(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_self = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); #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); __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; __Pyx_GOTREF(__pyx_v_kwargs); __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); if (unlikely(!__pyx_v_args)) { __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_RefNannyFinishContext(); return NULL; } __Pyx_GOTREF(__pyx_v_args); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { default: case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; } 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_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 66, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, used_pos_args, "__call__") < 0)) __PYX_ERR(0, 66, __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_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 66, __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_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_AddTraceback("pyliblo3._liblo._weakref_method.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_15_weakref_method_4__call__(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs); /* function exit code */ __Pyx_DECREF(__pyx_v_args); __Pyx_DECREF(__pyx_v_kwargs); { 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_8pyliblo3_6_liblo_15_weakref_method_4__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 1); /* "pyliblo3/_liblo.pyx":67 * * def __call__(self, *args, **kwargs): * return self.func(*args, **kwargs) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_func_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":66 * return self._func * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< * return self.func(*args, **kwargs) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo._weakref_method.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":71 * * class struct: * def __init__(self, **kwargs): # <<<<<<<<<<<<<< * for k, v in kwargs.items(): * setattr(self, k, v) */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6struct_1__init__(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_8pyliblo3_6_liblo_6struct___init__, "struct.__init__(self, **kwargs)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6struct_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6struct_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6struct___init__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6struct_1__init__(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_self = 0; PyObject *__pyx_v_kwargs = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if !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); __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; __Pyx_GOTREF(__pyx_v_kwargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,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_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 71, __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, __pyx_v_kwargs, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 71, __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_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 71, __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_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_AddTraceback("pyliblo3._liblo.struct.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6struct___init__(__pyx_self, __pyx_v_self, __pyx_v_kwargs); /* function exit code */ __Pyx_DECREF(__pyx_v_kwargs); { 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_8pyliblo3_6_liblo_6struct___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_kwargs) { PyObject *__pyx_v_k = NULL; PyObject *__pyx_v_v = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":72 * class struct: * def __init__(self, **kwargs): * for k, v in kwargs.items(): # <<<<<<<<<<<<<< * setattr(self, k, v) * */ __pyx_t_2 = 0; __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_kwargs, 1, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_5; __pyx_t_5 = 0; while (1) { __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); if (unlikely(__pyx_t_7 == 0)) break; if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_6); __pyx_t_6 = 0; /* "pyliblo3/_liblo.pyx":73 * def __init__(self, **kwargs): * for k, v in kwargs.items(): * setattr(self, k, v) # <<<<<<<<<<<<<< * * */ __pyx_t_8 = PyObject_SetAttr(__pyx_v_self, __pyx_v_k, __pyx_v_v); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 73, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":71 * * class struct: * def __init__(self, **kwargs): # <<<<<<<<<<<<<< * for k, v in kwargs.items(): * setattr(self, k, v) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyliblo3._liblo.struct.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_k); __Pyx_XDECREF(__pyx_v_v); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":89 * cdef int has_varargs * * def __init__(self, func, user_data): # <<<<<<<<<<<<<< * self.func = _weakref_method(func) * self.user_data = user_data, */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_8Callback_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_8Callback_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_func = 0; PyObject *__pyx_v_user_data = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_func_3,&__pyx_n_s_user_data,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_func_3)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_user_data)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 89, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 89, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); } __pyx_v_func = values[0]; __pyx_v_user_data = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 89, __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("pyliblo3._liblo.Callback.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_8Callback___init__(((struct __pyx_obj_8pyliblo3_6_liblo_Callback *)__pyx_v_self), __pyx_v_func, __pyx_v_user_data); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_8Callback___init__(struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_self, PyObject *__pyx_v_func, PyObject *__pyx_v_user_data) { PyObject *__pyx_v_spec = NULL; PyObject *__pyx_v_numargs = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; Py_ssize_t __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":90 * * def __init__(self, func, user_data): * self.func = _weakref_method(func) # <<<<<<<<<<<<<< * self.user_data = user_data, * spec = _inspect.getfullargspec(func) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref_method); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_func}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->func); __Pyx_DECREF(__pyx_v_self->func); __pyx_v_self->func = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":91 * def __init__(self, func, user_data): * self.func = _weakref_method(func) * self.user_data = user_data, # <<<<<<<<<<<<<< * spec = _inspect.getfullargspec(func) * numargs = len(spec.args) */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_user_data); __Pyx_GIVEREF(__pyx_v_user_data); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_user_data)) __PYX_ERR(0, 91, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->user_data); __Pyx_DECREF(__pyx_v_self->user_data); __pyx_v_self->user_data = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":92 * self.func = _weakref_method(func) * self.user_data = user_data, * spec = _inspect.getfullargspec(func) # <<<<<<<<<<<<<< * numargs = len(spec.args) * if _inspect.ismethod(func): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_inspect); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getfullargspec); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_func}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_spec = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":93 * self.user_data = user_data, * spec = _inspect.getfullargspec(func) * numargs = len(spec.args) # <<<<<<<<<<<<<< * if _inspect.ismethod(func): * numargs -= 1 */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_spec, __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_numargs = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":94 * spec = _inspect.getfullargspec(func) * numargs = len(spec.args) * if _inspect.ismethod(func): # <<<<<<<<<<<<<< * numargs -= 1 * self.numargs = numargs */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_inspect); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ismethod); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_4 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_4 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_func}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_6) { /* "pyliblo3/_liblo.pyx":95 * numargs = len(spec.args) * if _inspect.ismethod(func): * numargs -= 1 # <<<<<<<<<<<<<< * self.numargs = numargs * self.has_varargs = 1 if spec.varargs is not None else 0 */ __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_numargs, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_numargs, __pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":94 * spec = _inspect.getfullargspec(func) * numargs = len(spec.args) * if _inspect.ismethod(func): # <<<<<<<<<<<<<< * numargs -= 1 * self.numargs = numargs */ } /* "pyliblo3/_liblo.pyx":96 * if _inspect.ismethod(func): * numargs -= 1 * self.numargs = numargs # <<<<<<<<<<<<<< * self.has_varargs = 1 if spec.varargs is not None else 0 * */ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_numargs); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L1_error) __pyx_v_self->numargs = __pyx_t_4; /* "pyliblo3/_liblo.pyx":97 * numargs -= 1 * self.numargs = numargs * self.has_varargs = 1 if spec.varargs is not None else 0 # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_spec, __pyx_n_s_varargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_6) { __pyx_t_4 = 1; } else { __pyx_t_4 = 0; } __pyx_v_self->has_varargs = __pyx_t_4; /* "pyliblo3/_liblo.pyx":89 * cdef int has_varargs * * def __init__(self, func, user_data): # <<<<<<<<<<<<<< * self.func = _weakref_method(func) * self.user_data = user_data, */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo.Callback.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_spec); __Pyx_XDECREF(__pyx_v_numargs); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_8Callback_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_8pyliblo3_6_liblo_8Callback_2__reduce_cython__, "Callback.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_8Callback_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_8Callback_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_8Callback_2__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_8Callback_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_8pyliblo3_6_liblo_8Callback_2__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Callback *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_8Callback_2__reduce_cython__(struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.func, self.has_varargs, self.numargs, self.user_data) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->has_varargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->numargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_self->func); __Pyx_GIVEREF(__pyx_v_self->func); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self->func)) __PYX_ERR(2, 5, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error); __Pyx_INCREF(__pyx_v_self->user_data); __Pyx_GIVEREF(__pyx_v_self->user_data); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_self->user_data)) __PYX_ERR(2, 5, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_v_state = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.func, self.has_varargs, self.numargs, self.user_data) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_3 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v__dict = __pyx_t_3; __pyx_t_3 = 0; /* "(tree fragment)":7 * state = (self.func, self.has_varargs, self.numargs, self.user_data) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_4 = (__pyx_v__dict != Py_None); if (__pyx_t_4) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__dict)) __PYX_ERR(2, 8, __pyx_L1_error); __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_2)); __pyx_t_2 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.func is not None or self.user_data is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.func, self.has_varargs, self.numargs, self.user_data) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.func is not None or self.user_data is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, None), state */ /*else*/ { __pyx_t_5 = (__pyx_v_self->func != Py_None); if (!__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = (__pyx_v_self->user_data != Py_None); __pyx_t_4 = __pyx_t_5; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_4; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.func is not None or self.user_data is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Callback, (type(self), 0xb933e34, None), state * else: */ if (__pyx_v_use_setstate) { /* "(tree fragment)":13 * use_setstate = self.func is not None or self.user_data is not None * if use_setstate: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle_Callback); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(2, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_int_194199092); __Pyx_GIVEREF(__pyx_int_194199092); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_194199092)) __PYX_ERR(2, 13, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None)) __PYX_ERR(2, 13, __pyx_L1_error); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2)) __PYX_ERR(2, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3)) __PYX_ERR(2, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(2, 13, __pyx_L1_error); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.func is not None or self.user_data is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Callback, (type(self), 0xb933e34, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_Callback, (type(self), 0xb933e34, None), state * else: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Callback__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pyx_unpickle_Callback); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(2, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_int_194199092); __Pyx_GIVEREF(__pyx_int_194199092); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_194199092)) __PYX_ERR(2, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state)) __PYX_ERR(2, 15, __pyx_L1_error); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3)) __PYX_ERR(2, 15, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo.Callback.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Callback__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_8Callback_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_8pyliblo3_6_liblo_8Callback_4__setstate_cython__, "Callback.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_8Callback_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_8Callback_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_8Callback_4__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_8Callback_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 ) { PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 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(2, 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(2, 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("pyliblo3._liblo.Callback.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_8Callback_4__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Callback *)__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_8pyliblo3_6_liblo_8Callback_4__setstate_cython__(struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_self, 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__", 1); /* "(tree fragment)":17 * return __pyx_unpickle_Callback, (type(self), 0xb933e34, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Callback__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(2, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo___pyx_unpickle_Callback__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Callback__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo.Callback.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":100 * * * cdef inline str _decode(s): # <<<<<<<<<<<<<< * # convert to standard string type, depending on python version * if PY_VERSION_HEX >= 0x03000000 and isinstance(s, bytes): */ static CYTHON_INLINE PyObject *__pyx_f_8pyliblo3_6_liblo__decode(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_decode", 1); /* "pyliblo3/_liblo.pyx":102 * cdef inline str _decode(s): * # convert to standard string type, depending on python version * if PY_VERSION_HEX >= 0x03000000 and isinstance(s, bytes): # <<<<<<<<<<<<<< * return s.decode() * else: */ __pyx_t_2 = (PY_VERSION_HEX >= 0x03000000); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = PyBytes_Check(__pyx_v_s); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":103 * # convert to standard string type, depending on python version * if PY_VERSION_HEX >= 0x03000000 and isinstance(s, bytes): * return s.decode() # <<<<<<<<<<<<<< * else: * return s */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_t_3))) __PYX_ERR(0, 103, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":102 * cdef inline str _decode(s): * # convert to standard string type, depending on python version * if PY_VERSION_HEX >= 0x03000000 and isinstance(s, bytes): # <<<<<<<<<<<<<< * return s.decode() * else: */ } /* "pyliblo3/_liblo.pyx":105 * return s.decode() * else: * return s # <<<<<<<<<<<<<< * * cdef bytes _encode(s): */ /*else*/ { __Pyx_XDECREF(__pyx_r); if (!(likely(PyString_CheckExact(__pyx_v_s))||((__pyx_v_s) == Py_None) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_v_s))) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_INCREF(__pyx_v_s); __pyx_r = ((PyObject*)__pyx_v_s); goto __pyx_L0; } /* "pyliblo3/_liblo.pyx":100 * * * cdef inline str _decode(s): # <<<<<<<<<<<<<< * # convert to standard string type, depending on python version * if PY_VERSION_HEX >= 0x03000000 and isinstance(s, bytes): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyliblo3._liblo._decode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":107 * return s * * cdef bytes _encode(s): # <<<<<<<<<<<<<< * # convert unicode to bytestring * if isinstance(s, unicode): */ static PyObject *__pyx_f_8pyliblo3_6_liblo__encode(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_encode", 1); /* "pyliblo3/_liblo.pyx":109 * cdef bytes _encode(s): * # convert unicode to bytestring * if isinstance(s, unicode): # <<<<<<<<<<<<<< * return s.encode() * else: */ __pyx_t_1 = PyUnicode_Check(__pyx_v_s); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":110 * # convert unicode to bytestring * if isinstance(s, unicode): * return s.encode() # <<<<<<<<<<<<<< * else: * return s */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_2))) __PYX_ERR(0, 110, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":109 * cdef bytes _encode(s): * # convert unicode to bytestring * if isinstance(s, unicode): # <<<<<<<<<<<<<< * return s.encode() * else: */ } /* "pyliblo3/_liblo.pyx":112 * return s.encode() * else: * return s # <<<<<<<<<<<<<< * * */ /*else*/ { __Pyx_XDECREF(__pyx_r); if (!(likely(PyBytes_CheckExact(__pyx_v_s))||((__pyx_v_s) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_s))) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_INCREF(__pyx_v_s); __pyx_r = ((PyObject*)__pyx_v_s); goto __pyx_L0; } /* "pyliblo3/_liblo.pyx":107 * return s * * cdef bytes _encode(s): # <<<<<<<<<<<<<< * # convert unicode to bytestring * if isinstance(s, unicode): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyliblo3._liblo._encode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":132 * ################################################################################ * * cdef lo_timetag _double_to_timetag(double f): # <<<<<<<<<<<<<< * cdef lo_timetag tt * cdef double intr, frac */ static lo_timetag __pyx_f_8pyliblo3_6_liblo__double_to_timetag(double __pyx_v_f) { lo_timetag __pyx_v_tt; double __pyx_v_intr; double __pyx_v_frac; lo_timetag __pyx_r; /* "pyliblo3/_liblo.pyx":135 * cdef lo_timetag tt * cdef double intr, frac * frac = modf(f, &intr) # <<<<<<<<<<<<<< * tt.sec = intr * tt.frac = (frac * 4294967296.0) */ __pyx_v_frac = modf(__pyx_v_f, (&__pyx_v_intr)); /* "pyliblo3/_liblo.pyx":136 * cdef double intr, frac * frac = modf(f, &intr) * tt.sec = intr # <<<<<<<<<<<<<< * tt.frac = (frac * 4294967296.0) * return tt */ __pyx_v_tt.sec = ((uint32_t)__pyx_v_intr); /* "pyliblo3/_liblo.pyx":137 * frac = modf(f, &intr) * tt.sec = intr * tt.frac = (frac * 4294967296.0) # <<<<<<<<<<<<<< * return tt * */ __pyx_v_tt.frac = ((uint32_t)(__pyx_v_frac * 4294967296.0)); /* "pyliblo3/_liblo.pyx":138 * tt.sec = intr * tt.frac = (frac * 4294967296.0) * return tt # <<<<<<<<<<<<<< * * cdef double _timetag_to_double(lo_timetag tt): */ __pyx_r = __pyx_v_tt; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":132 * ################################################################################ * * cdef lo_timetag _double_to_timetag(double f): # <<<<<<<<<<<<<< * cdef lo_timetag tt * cdef double intr, frac */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "pyliblo3/_liblo.pyx":140 * return tt * * cdef double _timetag_to_double(lo_timetag tt): # <<<<<<<<<<<<<< * return tt.sec + ((tt.frac) / 4294967296.0) * */ static double __pyx_f_8pyliblo3_6_liblo__timetag_to_double(lo_timetag __pyx_v_tt) { double __pyx_r; /* "pyliblo3/_liblo.pyx":141 * * cdef double _timetag_to_double(lo_timetag tt): * return tt.sec + ((tt.frac) / 4294967296.0) # <<<<<<<<<<<<<< * * def time(): */ __pyx_r = (((double)__pyx_v_tt.sec) + (((double)__pyx_v_tt.frac) / 4294967296.0)); goto __pyx_L0; /* "pyliblo3/_liblo.pyx":140 * return tt * * cdef double _timetag_to_double(lo_timetag tt): # <<<<<<<<<<<<<< * return tt.sec + ((tt.frac) / 4294967296.0) * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "pyliblo3/_liblo.pyx":143 * return tt.sec + ((tt.frac) / 4294967296.0) * * def time(): # <<<<<<<<<<<<<< * """ * Return the current time as a floating point number (seconds since January 1, 1900). */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_3time(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ PyDoc_STRVAR(__pyx_doc_8pyliblo3_6_liblo_2time, "time()\n\n Return the current time as a floating point number (seconds since January 1, 1900).\n\n Returns:\n (float) The liblo timetag as a float, representing seconds since 1900\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_3time = {"time", (PyCFunction)__pyx_pw_8pyliblo3_6_liblo_3time, METH_NOARGS, __pyx_doc_8pyliblo3_6_liblo_2time}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_3time(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("time (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_8pyliblo3_6_liblo_2time(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_2time(CYTHON_UNUSED PyObject *__pyx_self) { lo_timetag __pyx_v_tt; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations double __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("time", 1); /* "pyliblo3/_liblo.pyx":151 * """ * cdef lo_timetag tt * lo_timetag_now(&tt) # <<<<<<<<<<<<<< * return _timetag_to_double(tt) * */ lo_timetag_now((&__pyx_v_tt)); /* "pyliblo3/_liblo.pyx":152 * cdef lo_timetag tt * lo_timetag_now(&tt) * return _timetag_to_double(tt) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__timetag_to_double(__pyx_v_tt); if (unlikely(__pyx_t_1 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 152, __pyx_L1_error) __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":143 * return tt.sec + ((tt.frac) / 4294967296.0) * * def time(): # <<<<<<<<<<<<<< * """ * Return the current time as a floating point number (seconds since January 1, 1900). */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo.time", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":159 * ################################################################################ * * cdef _send(target, _ServerBase src, args): # <<<<<<<<<<<<<< * cdef lo_server from_server * cdef Address target_address */ static PyObject *__pyx_f_8pyliblo3_6_liblo__send(PyObject *__pyx_v_target, struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_src, PyObject *__pyx_v_args) { lo_server __pyx_v_from_server; struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_target_address = 0; int __pyx_v_r; PyObject *__pyx_v_packets = NULL; PyObject *__pyx_v_p = NULL; struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_message = NULL; struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_bundle = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; lo_server __pyx_t_4; int __pyx_t_5; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); char *__pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_send", 1); /* "pyliblo3/_liblo.pyx":165 * * # convert target to Address object, if necessary * if isinstance(target, Address): # <<<<<<<<<<<<<< * target_address = target * elif isinstance(target, tuple): */ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_target, __pyx_ptype_8pyliblo3_6_liblo_Address); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":166 * # convert target to Address object, if necessary * if isinstance(target, Address): * target_address = target # <<<<<<<<<<<<<< * elif isinstance(target, tuple): * # unpack tuple */ if (!(likely(((__pyx_v_target) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_target, __pyx_ptype_8pyliblo3_6_liblo_Address))))) __PYX_ERR(0, 166, __pyx_L1_error) __pyx_t_2 = __pyx_v_target; __Pyx_INCREF(__pyx_t_2); __pyx_v_target_address = ((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":165 * * # convert target to Address object, if necessary * if isinstance(target, Address): # <<<<<<<<<<<<<< * target_address = target * elif isinstance(target, tuple): */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":167 * if isinstance(target, Address): * target_address = target * elif isinstance(target, tuple): # <<<<<<<<<<<<<< * # unpack tuple * target_address = Address(*target) */ __pyx_t_1 = PyTuple_Check(__pyx_v_target); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":169 * elif isinstance(target, tuple): * # unpack tuple * target_address = Address(*target) # <<<<<<<<<<<<<< * else: * target_address = Address(target) */ __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_target); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Address), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_target_address = ((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":167 * if isinstance(target, Address): * target_address = target * elif isinstance(target, tuple): # <<<<<<<<<<<<<< * # unpack tuple * target_address = Address(*target) */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":171 * target_address = Address(*target) * else: * target_address = Address(target) # <<<<<<<<<<<<<< * * # 'from' parameter is NULL if no server was specified */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Address), __pyx_v_target); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_target_address = ((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "pyliblo3/_liblo.pyx":174 * * # 'from' parameter is NULL if no server was specified * from_server = src._server if src else NULL # <<<<<<<<<<<<<< * * if isinstance(args[0], (Message, Bundle)): */ __pyx_t_1 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_src)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 174, __pyx_L1_error) if (__pyx_t_1) { __pyx_t_4 = __pyx_v_src->_server; } else { __pyx_t_4 = NULL; } __pyx_v_from_server = __pyx_t_4; /* "pyliblo3/_liblo.pyx":176 * from_server = src._server if src else NULL * * if isinstance(args[0], (Message, Bundle)): # <<<<<<<<<<<<<< * # args is already a list of Messages/Bundles * packets = args */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_TypeCheck(__pyx_t_3, __pyx_ptype_8pyliblo3_6_liblo_Message); if (!__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; goto __pyx_L5_bool_binop_done; } __pyx_t_5 = __Pyx_TypeCheck(__pyx_t_3, __pyx_ptype_8pyliblo3_6_liblo_Bundle); __pyx_t_1 = __pyx_t_5; __pyx_L5_bool_binop_done:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":178 * if isinstance(args[0], (Message, Bundle)): * # args is already a list of Messages/Bundles * packets = args # <<<<<<<<<<<<<< * else: * # make a single Message from all arguments */ __Pyx_INCREF(__pyx_v_args); __pyx_v_packets = __pyx_v_args; /* "pyliblo3/_liblo.pyx":176 * from_server = src._server if src else NULL * * if isinstance(args[0], (Message, Bundle)): # <<<<<<<<<<<<<< * # args is already a list of Messages/Bundles * packets = args */ goto __pyx_L4; } /* "pyliblo3/_liblo.pyx":181 * else: * # make a single Message from all arguments * packets = [Message(*args)] # <<<<<<<<<<<<<< * * # send all packets */ /*else*/ { __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Message), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error); __pyx_t_2 = 0; __pyx_v_packets = __pyx_t_3; __pyx_t_3 = 0; } __pyx_L4:; /* "pyliblo3/_liblo.pyx":184 * * # send all packets * for p in packets: # <<<<<<<<<<<<<< * if isinstance(p, Message): * message = p */ if (likely(PyList_CheckExact(__pyx_v_packets)) || PyTuple_CheckExact(__pyx_v_packets)) { __pyx_t_3 = __pyx_v_packets; __Pyx_INCREF(__pyx_t_3); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_packets); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_3))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 184, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 184, __pyx_L1_error) #else __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 184, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 184, __pyx_L1_error) #else __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } } else { __pyx_t_2 = __pyx_t_7(__pyx_t_3); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 184, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_2); } __Pyx_XDECREF_SET(__pyx_v_p, __pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":185 * # send all packets * for p in packets: * if isinstance(p, Message): # <<<<<<<<<<<<<< * message = p * r = lo_send_message_from(target_address._address, */ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_p, __pyx_ptype_8pyliblo3_6_liblo_Message); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":186 * for p in packets: * if isinstance(p, Message): * message = p # <<<<<<<<<<<<<< * r = lo_send_message_from(target_address._address, * from_server, */ __pyx_t_2 = __pyx_v_p; __Pyx_INCREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_message, ((struct __pyx_obj_8pyliblo3_6_liblo_Message *)__pyx_t_2)); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":189 * r = lo_send_message_from(target_address._address, * from_server, * message._path, # <<<<<<<<<<<<<< * message._message) * else: */ if (unlikely(__pyx_v_message->_path == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 189, __pyx_L1_error) } __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_message->_path); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(0, 189, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":187 * if isinstance(p, Message): * message = p * r = lo_send_message_from(target_address._address, # <<<<<<<<<<<<<< * from_server, * message._path, */ __pyx_v_r = lo_send_message_from(__pyx_v_target_address->_address, __pyx_v_from_server, __pyx_t_8, __pyx_v_message->_message); /* "pyliblo3/_liblo.pyx":185 * # send all packets * for p in packets: * if isinstance(p, Message): # <<<<<<<<<<<<<< * message = p * r = lo_send_message_from(target_address._address, */ goto __pyx_L9; } /* "pyliblo3/_liblo.pyx":192 * message._message) * else: * bundle = p # <<<<<<<<<<<<<< * r = lo_send_bundle_from(target_address._address, * from_server, */ /*else*/ { __pyx_t_2 = __pyx_v_p; __Pyx_INCREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_bundle, ((struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)__pyx_t_2)); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":193 * else: * bundle = p * r = lo_send_bundle_from(target_address._address, # <<<<<<<<<<<<<< * from_server, * bundle._bundle) */ __pyx_v_r = lo_send_bundle_from(__pyx_v_target_address->_address, __pyx_v_from_server, __pyx_v_bundle->_bundle); } __pyx_L9:; /* "pyliblo3/_liblo.pyx":197 * bundle._bundle) * * if r == -1: # <<<<<<<<<<<<<< * raise IOError("sending failed: %s" % * lo_address_errstr(target_address._address)) */ __pyx_t_1 = (__pyx_v_r == -1L); if (unlikely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":199 * if r == -1: * raise IOError("sending failed: %s" % * lo_address_errstr(target_address._address)) # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyBytes_FromString(((char *)lo_address_errstr(__pyx_v_target_address->_address))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pyliblo3/_liblo.pyx":198 * * if r == -1: * raise IOError("sending failed: %s" % # <<<<<<<<<<<<<< * lo_address_errstr(target_address._address)) * */ __pyx_t_9 = __Pyx_PyString_Format(__pyx_kp_s_sending_failed_s, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IOError, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 198, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":197 * bundle._bundle) * * if r == -1: # <<<<<<<<<<<<<< * raise IOError("sending failed: %s" % * lo_address_errstr(target_address._address)) */ } /* "pyliblo3/_liblo.pyx":184 * * # send all packets * for p in packets: # <<<<<<<<<<<<<< * if isinstance(p, Message): * message = p */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":159 * ################################################################################ * * cdef _send(target, _ServerBase src, args): # <<<<<<<<<<<<<< * cdef lo_server from_server * cdef Address target_address */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("pyliblo3._liblo._send", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_target_address); __Pyx_XDECREF(__pyx_v_packets); __Pyx_XDECREF(__pyx_v_p); __Pyx_XDECREF((PyObject *)__pyx_v_message); __Pyx_XDECREF((PyObject *)__pyx_v_bundle); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":202 * * * def send(target, *args): # <<<<<<<<<<<<<< * """ * Send a message without requiring a server */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_5send(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_8pyliblo3_6_liblo_4send, "send(target, *args)\n\n Send a message without requiring a server\n\n The function has two forms:\n\n * `send(target, *messages)`\n * `send(target, path, *args)`\n\n Send messages to the the given target, without requiring a server.\n Arguments may be one or more `Message` or `Bundle` objects,\n or a single message given by its path and optional arguments.\n\n Args:\n target (Address | tuple[str, int] | int | str): the address to send the message to;\n an `Address` object, a port number, a `(hostname, port)` tuple, or a URL.\n path (str): the path of the message to be sent\n args (Any): the information to send. These are used to construct a message\n messages (Message | Bundle): one or more objects of type `Message` or `Bundle`.\n\n Raises:\n AddressError: if the given target is invalid\n IOError: if the message couldn't be sent.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_5send = {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_5send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_4send}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_5send(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_target = 0; PyObject *__pyx_v_args = 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("send (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); __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); if (unlikely(!__pyx_v_args)) { __Pyx_RefNannyFinishContext(); return NULL; } __Pyx_GOTREF(__pyx_v_args); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_target,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { default: case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; } 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_target)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 202, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, used_pos_args, "send") < 0)) __PYX_ERR(0, 202, __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_target = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("send", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 202, __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_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_AddTraceback("pyliblo3._liblo.send", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_4send(__pyx_self, __pyx_v_target, __pyx_v_args); /* function exit code */ __Pyx_DECREF(__pyx_v_args); { 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_8pyliblo3_6_liblo_4send(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_target, PyObject *__pyx_v_args) { 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("send", 1); /* "pyliblo3/_liblo.pyx":226 * IOError: if the message couldn't be sent. * """ * _send(target, None, args) # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__send(__pyx_v_target, ((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)Py_None), __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":202 * * * def send(target, *args): # <<<<<<<<<<<<<< * """ * Send a message without requiring a server */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo.send", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":237 * Raised when creating a liblo OSC server fails. * """ * def __init__(self, num, msg, where): # <<<<<<<<<<<<<< * self.num = num * self.msg = msg */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11ServerError_1__init__(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_8pyliblo3_6_liblo_11ServerError___init__, "ServerError.__init__(self, num, msg, where)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11ServerError_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11ServerError_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11ServerError___init__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11ServerError_1__init__(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_self = 0; PyObject *__pyx_v_num = 0; PyObject *__pyx_v_msg = 0; PyObject *__pyx_v_where = 0; #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("__init__ (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_self,&__pyx_n_s_num,&__pyx_n_s_msg,&__pyx_n_s_where,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(0, 237, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_msg)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(0, 237, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_where)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(0, 237, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 237, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_self = values[0]; __pyx_v_num = values[1]; __pyx_v_msg = values[2]; __pyx_v_where = values[3]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 237, __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("pyliblo3._liblo.ServerError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11ServerError___init__(__pyx_self, __pyx_v_self, __pyx_v_num, __pyx_v_msg, __pyx_v_where); /* 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_8pyliblo3_6_liblo_11ServerError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_num, PyObject *__pyx_v_msg, PyObject *__pyx_v_where) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":238 * """ * def __init__(self, num, msg, where): * self.num = num # <<<<<<<<<<<<<< * self.msg = msg * self.where = where */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_num, __pyx_v_num) < 0) __PYX_ERR(0, 238, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":239 * def __init__(self, num, msg, where): * self.num = num * self.msg = msg # <<<<<<<<<<<<<< * self.where = where * def __str__(self): */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_msg, __pyx_v_msg) < 0) __PYX_ERR(0, 239, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":240 * self.num = num * self.msg = msg * self.where = where # <<<<<<<<<<<<<< * def __str__(self): * s = "server error %d" % self.num */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_where, __pyx_v_where) < 0) __PYX_ERR(0, 240, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":237 * Raised when creating a liblo OSC server fails. * """ * def __init__(self, num, msg, where): # <<<<<<<<<<<<<< * self.num = num * self.msg = msg */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.ServerError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":241 * self.msg = msg * self.where = where * def __str__(self): # <<<<<<<<<<<<<< * s = "server error %d" % self.num * if self.where: s += " in %s" % self.where */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11ServerError_3__str__(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_8pyliblo3_6_liblo_11ServerError_2__str__, "ServerError.__str__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11ServerError_3__str__ = {"__str__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11ServerError_3__str__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11ServerError_2__str__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11ServerError_3__str__(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_self = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); #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_self,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_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 241, __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, "__str__") < 0)) __PYX_ERR(0, 241, __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_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 241, __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("pyliblo3._liblo.ServerError.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11ServerError_2__str__(__pyx_self, __pyx_v_self); /* 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_8pyliblo3_6_liblo_11ServerError_2__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_s = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 1); /* "pyliblo3/_liblo.pyx":242 * self.where = where * def __str__(self): * s = "server error %d" % self.num # <<<<<<<<<<<<<< * if self.where: s += " in %s" % self.where * s += ": %s" % self.msg */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_num); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_server_error_d, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_s = __pyx_t_2; __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":243 * def __str__(self): * s = "server error %d" % self.num * if self.where: s += " in %s" % self.where # <<<<<<<<<<<<<< * s += ": %s" % self.msg * return s */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_where); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_3) { __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_where); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyString_FormatSafe(__pyx_kp_s_in_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_s, __pyx_t_2); __pyx_t_2 = 0; } /* "pyliblo3/_liblo.pyx":244 * s = "server error %d" % self.num * if self.where: s += " in %s" % self.where * s += ": %s" % self.msg # <<<<<<<<<<<<<< * return s * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_msg); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyString_FormatSafe(__pyx_kp_s_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_s, __pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":245 * if self.where: s += " in %s" % self.where * s += ": %s" % self.msg * return s # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":241 * self.msg = msg * self.where = where * def __str__(self): # <<<<<<<<<<<<<< * s = "server error %d" % self.num * if self.where: s += " in %s" % self.where */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo.ServerError.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_s); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":248 * * * cdef int _msg_callback(const_char *path, const_char *types, lo_arg **argv, # <<<<<<<<<<<<<< * int argc, lo_message msg, void *cb_data) noexcept with gil: * cdef int i */ static int __pyx_f_8pyliblo3_6_liblo__msg_callback(const char *__pyx_v_path, const char *__pyx_v_types, lo_arg **__pyx_v_argv, int __pyx_v_argc, lo_message __pyx_v_msg, void *__pyx_v_cb_data) { int __pyx_v_i; char __pyx_v_t; PyObject *__pyx_v_args = NULL; PyObject *__pyx_v_v = NULL; char *__pyx_v_url; struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_src = NULL; struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_cb = NULL; PyObject *__pyx_v_func_args = NULL; PyObject *__pyx_v_r = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; double __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_msg_callback", 0); /* "pyliblo3/_liblo.pyx":255 * cdef uint32_t size, j * * args = [] # <<<<<<<<<<<<<< * * for i from 0 <= i < argc: */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_args = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":257 * args = [] * * for i from 0 <= i < argc: # <<<<<<<<<<<<<< * t = types[i] * if t == 'i': v = argv[i].i */ __pyx_t_2 = __pyx_v_argc; for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) { /* "pyliblo3/_liblo.pyx":258 * * for i from 0 <= i < argc: * t = types[i] # <<<<<<<<<<<<<< * if t == 'i': v = argv[i].i * elif t == 'h': v = argv[i].h */ __pyx_v_t = (__pyx_v_types[__pyx_v_i]); /* "pyliblo3/_liblo.pyx":259 * for i from 0 <= i < argc: * t = types[i] * if t == 'i': v = argv[i].i # <<<<<<<<<<<<<< * elif t == 'h': v = argv[i].h * elif t == 'f': v = argv[i].f */ switch (__pyx_v_t) { case 'i': __pyx_t_1 = __Pyx_PyInt_From_int32_t((__pyx_v_argv[__pyx_v_i])->i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 259, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1); __pyx_t_1 = 0; break; case 'h': /* "pyliblo3/_liblo.pyx":260 * t = types[i] * if t == 'i': v = argv[i].i * elif t == 'h': v = argv[i].h # <<<<<<<<<<<<<< * elif t == 'f': v = argv[i].f * elif t == 'd': v = argv[i].d */ __pyx_t_1 = __Pyx_PyInt_From_int64_t((__pyx_v_argv[__pyx_v_i])->h); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1); __pyx_t_1 = 0; break; case 'f': /* "pyliblo3/_liblo.pyx":261 * if t == 'i': v = argv[i].i * elif t == 'h': v = argv[i].h * elif t == 'f': v = argv[i].f # <<<<<<<<<<<<<< * elif t == 'd': v = argv[i].d * elif t == 'c': v = chr(argv[i].c) */ __pyx_t_1 = PyFloat_FromDouble((__pyx_v_argv[__pyx_v_i])->f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1); __pyx_t_1 = 0; break; case 'd': /* "pyliblo3/_liblo.pyx":262 * elif t == 'h': v = argv[i].h * elif t == 'f': v = argv[i].f * elif t == 'd': v = argv[i].d # <<<<<<<<<<<<<< * elif t == 'c': v = chr(argv[i].c) * elif t == 's': v = _decode(&argv[i].s) */ __pyx_t_1 = PyFloat_FromDouble((__pyx_v_argv[__pyx_v_i])->d); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1); __pyx_t_1 = 0; break; case 'c': /* "pyliblo3/_liblo.pyx":263 * elif t == 'f': v = argv[i].f * elif t == 'd': v = argv[i].d * elif t == 'c': v = chr(argv[i].c) # <<<<<<<<<<<<<< * elif t == 's': v = _decode(&argv[i].s) * elif t == 'S': v = _decode(&argv[i].s) */ __pyx_t_1 = __Pyx_PyInt_From_unsigned_char((__pyx_v_argv[__pyx_v_i])->c); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_chr, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_3); __pyx_t_3 = 0; break; case 's': /* "pyliblo3/_liblo.pyx":264 * elif t == 'd': v = argv[i].d * elif t == 'c': v = chr(argv[i].c) * elif t == 's': v = _decode(&argv[i].s) # <<<<<<<<<<<<<< * elif t == 'S': v = _decode(&argv[i].s) * elif t == 'T': v = True */ __pyx_t_3 = __Pyx_PyBytes_FromString((&(__pyx_v_argv[__pyx_v_i])->s)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1); __pyx_t_1 = 0; break; case 'S': /* "pyliblo3/_liblo.pyx":265 * elif t == 'c': v = chr(argv[i].c) * elif t == 's': v = _decode(&argv[i].s) * elif t == 'S': v = _decode(&argv[i].s) # <<<<<<<<<<<<<< * elif t == 'T': v = True * elif t == 'F': v = False */ __pyx_t_1 = __Pyx_PyBytes_FromString((&(__pyx_v_argv[__pyx_v_i])->s)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_3); __pyx_t_3 = 0; break; case 'T': /* "pyliblo3/_liblo.pyx":266 * elif t == 's': v = _decode(&argv[i].s) * elif t == 'S': v = _decode(&argv[i].s) * elif t == 'T': v = True # <<<<<<<<<<<<<< * elif t == 'F': v = False * elif t == 'N': v = None */ __Pyx_INCREF(Py_True); __Pyx_XDECREF_SET(__pyx_v_v, Py_True); break; case 'F': /* "pyliblo3/_liblo.pyx":267 * elif t == 'S': v = _decode(&argv[i].s) * elif t == 'T': v = True * elif t == 'F': v = False # <<<<<<<<<<<<<< * elif t == 'N': v = None * elif t == 'I': v = float('inf') */ __Pyx_INCREF(Py_False); __Pyx_XDECREF_SET(__pyx_v_v, Py_False); break; case 'N': /* "pyliblo3/_liblo.pyx":268 * elif t == 'T': v = True * elif t == 'F': v = False * elif t == 'N': v = None # <<<<<<<<<<<<<< * elif t == 'I': v = float('inf') * elif t == 'm': v = (argv[i].m[0], argv[i].m[1], argv[i].m[2], argv[i].m[3]) */ __Pyx_INCREF(Py_None); __Pyx_XDECREF_SET(__pyx_v_v, Py_None); break; case 'I': /* "pyliblo3/_liblo.pyx":269 * elif t == 'F': v = False * elif t == 'N': v = None * elif t == 'I': v = float('inf') # <<<<<<<<<<<<<< * elif t == 'm': v = (argv[i].m[0], argv[i].m[1], argv[i].m[2], argv[i].m[3]) * elif t == 't': v = _timetag_to_double(argv[i].t) */ __pyx_t_4 = __Pyx_PyString_AsDouble(__pyx_n_s_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 269, __pyx_L1_error) __pyx_t_3 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_3); __pyx_t_3 = 0; break; case 'm': /* "pyliblo3/_liblo.pyx":270 * elif t == 'N': v = None * elif t == 'I': v = float('inf') * elif t == 'm': v = (argv[i].m[0], argv[i].m[1], argv[i].m[2], argv[i].m[3]) # <<<<<<<<<<<<<< * elif t == 't': v = _timetag_to_double(argv[i].t) * elif t == 'b': */ __pyx_t_3 = __Pyx_PyInt_From_uint8_t(((__pyx_v_argv[__pyx_v_i])->m[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyInt_From_uint8_t(((__pyx_v_argv[__pyx_v_i])->m[1])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyInt_From_uint8_t(((__pyx_v_argv[__pyx_v_i])->m[2])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint8_t(((__pyx_v_argv[__pyx_v_i])->m[3])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_5)) __PYX_ERR(0, 270, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_6); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_6)) __PYX_ERR(0, 270, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_7); __pyx_t_7 = 0; break; case 't': /* "pyliblo3/_liblo.pyx":271 * elif t == 'I': v = float('inf') * elif t == 'm': v = (argv[i].m[0], argv[i].m[1], argv[i].m[2], argv[i].m[3]) * elif t == 't': v = _timetag_to_double(argv[i].t) # <<<<<<<<<<<<<< * elif t == 'b': * v = bytes(lo_blob_dataptr(argv[i])) */ __pyx_t_4 = __pyx_f_8pyliblo3_6_liblo__timetag_to_double((__pyx_v_argv[__pyx_v_i])->t); if (unlikely(__pyx_t_4 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 271, __pyx_L1_error) __pyx_t_7 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_7); __pyx_t_7 = 0; break; case 'b': /* "pyliblo3/_liblo.pyx":273 * elif t == 't': v = _timetag_to_double(argv[i].t) * elif t == 'b': * v = bytes(lo_blob_dataptr(argv[i])) # <<<<<<<<<<<<<< * else: * v = None # unhandled data type */ __pyx_t_7 = __Pyx_PyBytes_FromCString(((unsigned char *)lo_blob_dataptr((__pyx_v_argv[__pyx_v_i])))); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_6); __pyx_t_6 = 0; /* "pyliblo3/_liblo.pyx":272 * elif t == 'm': v = (argv[i].m[0], argv[i].m[1], argv[i].m[2], argv[i].m[3]) * elif t == 't': v = _timetag_to_double(argv[i].t) * elif t == 'b': # <<<<<<<<<<<<<< * v = bytes(lo_blob_dataptr(argv[i])) * else: */ break; default: /* "pyliblo3/_liblo.pyx":275 * v = bytes(lo_blob_dataptr(argv[i])) * else: * v = None # unhandled data type # <<<<<<<<<<<<<< * * args.append(v) */ __Pyx_INCREF(Py_None); __Pyx_XDECREF_SET(__pyx_v_v, Py_None); break; } /* "pyliblo3/_liblo.pyx":277 * v = None # unhandled data type * * args.append(v) # <<<<<<<<<<<<<< * * cdef char *url = lo_address_get_url(lo_message_get_source(msg)) */ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_v); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 277, __pyx_L1_error) } /* "pyliblo3/_liblo.pyx":279 * args.append(v) * * cdef char *url = lo_address_get_url(lo_message_get_source(msg)) # <<<<<<<<<<<<<< * src = Address(url) * free(url) */ __pyx_v_url = lo_address_get_url(lo_message_get_source(__pyx_v_msg)); /* "pyliblo3/_liblo.pyx":280 * * cdef char *url = lo_address_get_url(lo_message_get_source(msg)) * src = Address(url) # <<<<<<<<<<<<<< * free(url) * */ __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_url); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Address), __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_src = ((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_t_7); __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":281 * cdef char *url = lo_address_get_url(lo_message_get_source(msg)) * src = Address(url) * free(url) # <<<<<<<<<<<<<< * * cb = cb_data */ free(__pyx_v_url); /* "pyliblo3/_liblo.pyx":283 * free(url) * * cb = cb_data # <<<<<<<<<<<<<< * * func_args = (_decode(path), */ __pyx_t_7 = ((PyObject *)__pyx_v_cb_data); __Pyx_INCREF(__pyx_t_7); __pyx_v_cb = ((struct __pyx_obj_8pyliblo3_6_liblo_Callback *)__pyx_t_7); __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":285 * cb = cb_data * * func_args = (_decode(path), # <<<<<<<<<<<<<< * args, * _decode(types), */ __pyx_t_7 = __Pyx_PyBytes_FromString(((char *)__pyx_v_path)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":287 * func_args = (_decode(path), * args, * _decode(types), # <<<<<<<<<<<<<< * src, * cb.user_data) */ __pyx_t_7 = __Pyx_PyBytes_FromString(((char *)__pyx_v_types)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":285 * cb = cb_data * * func_args = (_decode(path), # <<<<<<<<<<<<<< * args, * _decode(types), */ __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_6); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error); __Pyx_INCREF(__pyx_v_args); __Pyx_GIVEREF(__pyx_v_args); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_args)) __PYX_ERR(0, 285, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_5)) __PYX_ERR(0, 285, __pyx_L1_error); __Pyx_INCREF((PyObject *)__pyx_v_src); __Pyx_GIVEREF((PyObject *)__pyx_v_src); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 3, ((PyObject *)__pyx_v_src))) __PYX_ERR(0, 285, __pyx_L1_error); __Pyx_INCREF(__pyx_v_cb->user_data); __Pyx_GIVEREF(__pyx_v_cb->user_data); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_v_cb->user_data)) __PYX_ERR(0, 285, __pyx_L1_error); __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_v_func_args = ((PyObject*)__pyx_t_7); __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":293 * # call function * # spec = _inspect.getfullargspec(func) * if cb.has_varargs == 1: # <<<<<<<<<<<<<< * r = cb.func(*func_args) * else: */ __pyx_t_9 = (__pyx_v_cb->has_varargs == 1); if (__pyx_t_9) { /* "pyliblo3/_liblo.pyx":294 * # spec = _inspect.getfullargspec(func) * if cb.has_varargs == 1: * r = cb.func(*func_args) # <<<<<<<<<<<<<< * else: * r = cb.func(*func_args[0:cb.numargs]) */ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_v_cb->func, __pyx_v_func_args, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_v_r = __pyx_t_7; __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":293 * # call function * # spec = _inspect.getfullargspec(func) * if cb.has_varargs == 1: # <<<<<<<<<<<<<< * r = cb.func(*func_args) * else: */ goto __pyx_L5; } /* "pyliblo3/_liblo.pyx":296 * r = cb.func(*func_args) * else: * r = cb.func(*func_args[0:cb.numargs]) # <<<<<<<<<<<<<< * * return r if r is not None else 0 */ /*else*/ { __pyx_t_7 = __Pyx_PyTuple_GetSlice(__pyx_v_func_args, 0, __pyx_v_cb->numargs); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_cb->func, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_r = __pyx_t_5; __pyx_t_5 = 0; } __pyx_L5:; /* "pyliblo3/_liblo.pyx":298 * r = cb.func(*func_args[0:cb.numargs]) * * return r if r is not None else 0 # <<<<<<<<<<<<<< * * */ __pyx_t_9 = (__pyx_v_r != Py_None); if (__pyx_t_9) { __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_r); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 298, __pyx_L1_error) __pyx_t_2 = __pyx_t_10; } else { __pyx_t_2 = 0; } __pyx_r = __pyx_t_2; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":248 * * * cdef int _msg_callback(const_char *path, const_char *types, lo_arg **argv, # <<<<<<<<<<<<<< * int argc, lo_message msg, void *cb_data) noexcept with gil: * cdef int i */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_WriteUnraisable("pyliblo3._liblo._msg_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_args); __Pyx_XDECREF(__pyx_v_v); __Pyx_XDECREF((PyObject *)__pyx_v_src); __Pyx_XDECREF((PyObject *)__pyx_v_cb); __Pyx_XDECREF(__pyx_v_func_args); __Pyx_XDECREF(__pyx_v_r); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "pyliblo3/_liblo.pyx":301 * * * cdef int _bundle_start_callback(lo_timetag t, void *cb_data) noexcept with gil: # <<<<<<<<<<<<<< * cb = cb_data * r = cb.start_func(_timetag_to_double(t), cb.user_data) */ static int __pyx_f_8pyliblo3_6_liblo__bundle_start_callback(lo_timetag __pyx_v_t, void *__pyx_v_cb_data) { PyObject *__pyx_v_cb = NULL; PyObject *__pyx_v_r = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; double __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_bundle_start_callback", 0); /* "pyliblo3/_liblo.pyx":302 * * cdef int _bundle_start_callback(lo_timetag t, void *cb_data) noexcept with gil: * cb = cb_data # <<<<<<<<<<<<<< * r = cb.start_func(_timetag_to_double(t), cb.user_data) * return r if r is not None else 0 */ __pyx_t_1 = ((PyObject *)__pyx_v_cb_data); __Pyx_INCREF(__pyx_t_1); __pyx_v_cb = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":303 * cdef int _bundle_start_callback(lo_timetag t, void *cb_data) noexcept with gil: * cb = cb_data * r = cb.start_func(_timetag_to_double(t), cb.user_data) # <<<<<<<<<<<<<< * return r if r is not None else 0 * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb, __pyx_n_s_start_func); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__timetag_to_double(__pyx_v_t); if (unlikely(__pyx_t_3 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 303, __pyx_L1_error) __pyx_t_4 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb, __pyx_n_s_user_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_r = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":304 * cb = cb_data * r = cb.start_func(_timetag_to_double(t), cb.user_data) * return r if r is not None else 0 # <<<<<<<<<<<<<< * * */ __pyx_t_8 = (__pyx_v_r != Py_None); if (__pyx_t_8) { __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_r); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 304, __pyx_L1_error) __pyx_t_7 = __pyx_t_9; } else { __pyx_t_7 = 0; } __pyx_r = __pyx_t_7; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":301 * * * cdef int _bundle_start_callback(lo_timetag t, void *cb_data) noexcept with gil: # <<<<<<<<<<<<<< * cb = cb_data * r = cb.start_func(_timetag_to_double(t), cb.user_data) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyliblo3._liblo._bundle_start_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_cb); __Pyx_XDECREF(__pyx_v_r); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "pyliblo3/_liblo.pyx":307 * * * cdef int _bundle_end_callback(void *cb_data) noexcept with gil: # <<<<<<<<<<<<<< * cb = cb_data * r = cb.end_func(cb.user_data) */ static int __pyx_f_8pyliblo3_6_liblo__bundle_end_callback(void *__pyx_v_cb_data) { PyObject *__pyx_v_cb = NULL; PyObject *__pyx_v_r = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_bundle_end_callback", 0); /* "pyliblo3/_liblo.pyx":308 * * cdef int _bundle_end_callback(void *cb_data) noexcept with gil: * cb = cb_data # <<<<<<<<<<<<<< * r = cb.end_func(cb.user_data) * return r if r is not None else 0 */ __pyx_t_1 = ((PyObject *)__pyx_v_cb_data); __Pyx_INCREF(__pyx_t_1); __pyx_v_cb = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":309 * cdef int _bundle_end_callback(void *cb_data) noexcept with gil: * cb = cb_data * r = cb.end_func(cb.user_data) # <<<<<<<<<<<<<< * return r if r is not None else 0 * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb, __pyx_n_s_end_func); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb, __pyx_n_s_user_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __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_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_r = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":310 * cb = cb_data * r = cb.end_func(cb.user_data) * return r if r is not None else 0 # <<<<<<<<<<<<<< * * */ __pyx_t_6 = (__pyx_v_r != Py_None); if (__pyx_t_6) { __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_r); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 310, __pyx_L1_error) __pyx_t_5 = __pyx_t_7; } else { __pyx_t_5 = 0; } __pyx_r = __pyx_t_5; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":307 * * * cdef int _bundle_end_callback(void *cb_data) noexcept with gil: # <<<<<<<<<<<<<< * cb = cb_data * r = cb.end_func(cb.user_data) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyliblo3._liblo._bundle_end_callback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_cb); __Pyx_XDECREF(__pyx_v_r); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "pyliblo3/_liblo.pyx":313 * * * cdef void _err_handler(int num, const_char *msg, const_char *where) noexcept with gil: # <<<<<<<<<<<<<< * # can't raise exception in cdef callback function, so use a global variable * # instead */ static void __pyx_f_8pyliblo3_6_liblo__err_handler(int __pyx_v_num, const char *__pyx_v_msg, const char *__pyx_v_where) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_handler", 0); /* "pyliblo3/_liblo.pyx":317 * # instead * global __exception * __exception = ServerError(num, msg, None) # <<<<<<<<<<<<<< * if where: __exception.where = where * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ServerError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_num); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyBytes_FromString(((char *)__pyx_v_msg)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_6 = 1; } } #endif { PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_4, Py_None}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 3+__pyx_t_6); __Pyx_XDECREF(__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; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } if (PyDict_SetItem(__pyx_d, __pyx_n_s_exception, __pyx_t_1) < 0) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":318 * global __exception * __exception = ServerError(num, msg, None) * if where: __exception.where = where # <<<<<<<<<<<<<< * * */ __pyx_t_7 = (__pyx_v_where != 0); if (__pyx_t_7) { __pyx_t_1 = __Pyx_PyBytes_FromString(((char *)__pyx_v_where)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_exception); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_PyObject_SetAttrStr(__pyx_t_2, __pyx_n_s_where, __pyx_t_1) < 0) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } /* "pyliblo3/_liblo.pyx":313 * * * cdef void _err_handler(int num, const_char *msg, const_char *where) noexcept with gil: # <<<<<<<<<<<<<< * # can't raise exception in cdef callback function, so use a global variable * # instead */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("pyliblo3._liblo._err_handler", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } /* "pyliblo3/_liblo.pyx":340 * _counter = 0 * * def __init__(self, path, types, user_data=None): # <<<<<<<<<<<<<< * self.spec = struct(counter=make_method._counter, * path=path, */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11make_method_1__init__(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_8pyliblo3_6_liblo_11make_method___init__, "make_method.__init__(self, path, types, user_data=None)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11make_method_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11make_method_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11make_method___init__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11make_method_1__init__(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_self = 0; PyObject *__pyx_v_path = 0; PyObject *__pyx_v_types = 0; PyObject *__pyx_v_user_data = 0; #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("__init__ (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_self,&__pyx_n_s_path,&__pyx_n_s_types,&__pyx_n_s_user_data,0}; values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 340, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 340, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 4, 1); __PYX_ERR(0, 340, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_types)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 340, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 4, 2); __PYX_ERR(0, 340, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_user_data); if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 340, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 340, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 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; } } __pyx_v_self = values[0]; __pyx_v_path = values[1]; __pyx_v_types = values[2]; __pyx_v_user_data = values[3]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 4, __pyx_nargs); __PYX_ERR(0, 340, __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("pyliblo3._liblo.make_method.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11make_method___init__(__pyx_self, __pyx_v_self, __pyx_v_path, __pyx_v_types, __pyx_v_user_data); /* 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_8pyliblo3_6_liblo_11make_method___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_types, PyObject *__pyx_v_user_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":341 * * def __init__(self, path, types, user_data=None): * self.spec = struct(counter=make_method._counter, # <<<<<<<<<<<<<< * path=path, * types=types, */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_struct); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_make_method); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_counter_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_counter, __pyx_t_4) < 0) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":342 * def __init__(self, path, types, user_data=None): * self.spec = struct(counter=make_method._counter, * path=path, # <<<<<<<<<<<<<< * types=types, * user_data=user_data) */ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_path, __pyx_v_path) < 0) __PYX_ERR(0, 341, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":343 * self.spec = struct(counter=make_method._counter, * path=path, * types=types, # <<<<<<<<<<<<<< * user_data=user_data) * make_method._counter += 1 */ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_types, __pyx_v_types) < 0) __PYX_ERR(0, 341, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":344 * path=path, * types=types, * user_data=user_data) # <<<<<<<<<<<<<< * make_method._counter += 1 * */ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_user_data, __pyx_v_user_data) < 0) __PYX_ERR(0, 341, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":341 * * def __init__(self, path, types, user_data=None): * self.spec = struct(counter=make_method._counter, # <<<<<<<<<<<<<< * path=path, * types=types, */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_spec, __pyx_t_4) < 0) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":345 * types=types, * user_data=user_data) * make_method._counter += 1 # <<<<<<<<<<<<<< * * def __call__(self, f): */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_make_method); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_counter_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_make_method); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_PyObject_SetAttrStr(__pyx_t_2, __pyx_n_s_counter_2, __pyx_t_4) < 0) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":340 * _counter = 0 * * def __init__(self, path, types, user_data=None): # <<<<<<<<<<<<<< * self.spec = struct(counter=make_method._counter, * path=path, */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyliblo3._liblo.make_method.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":347 * make_method._counter += 1 * * def __call__(self, f): # <<<<<<<<<<<<<< * # we can't access the Server object here, because at the time the * # decorator is run it doesn't even exist yet, so we store the */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11make_method_3__call__(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_8pyliblo3_6_liblo_11make_method_2__call__, "make_method.__call__(self, f)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11make_method_3__call__ = {"__call__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11make_method_3__call__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11make_method_2__call__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11make_method_3__call__(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_self = 0; PyObject *__pyx_v_f = 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("__call__ (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_self,&__pyx_n_s_f,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 347, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_f)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 347, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__call__", 1, 2, 2, 1); __PYX_ERR(0, 347, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__call__") < 0)) __PYX_ERR(0, 347, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_f = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__call__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 347, __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("pyliblo3._liblo.make_method.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11make_method_2__call__(__pyx_self, __pyx_v_self, __pyx_v_f); /* 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_8pyliblo3_6_liblo_11make_method_2__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_f) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 1); /* "pyliblo3/_liblo.pyx":351 * # decorator is run it doesn't even exist yet, so we store the * # path/typespec in the function object instead... * if not hasattr(f, '_method_spec'): # <<<<<<<<<<<<<< * f._method_spec = [] * f._method_spec.append(self.spec) */ __pyx_t_1 = __Pyx_HasAttr(__pyx_v_f, __pyx_n_s_method_spec); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 351, __pyx_L1_error) __pyx_t_2 = (!__pyx_t_1); if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":352 * # path/typespec in the function object instead... * if not hasattr(f, '_method_spec'): * f._method_spec = [] # <<<<<<<<<<<<<< * f._method_spec.append(self.spec) * return f */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_PyObject_SetAttrStr(__pyx_v_f, __pyx_n_s_method_spec, __pyx_t_3) < 0) __PYX_ERR(0, 352, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":351 * # decorator is run it doesn't even exist yet, so we store the * # path/typespec in the function object instead... * if not hasattr(f, '_method_spec'): # <<<<<<<<<<<<<< * f._method_spec = [] * f._method_spec.append(self.spec) */ } /* "pyliblo3/_liblo.pyx":353 * if not hasattr(f, '_method_spec'): * f._method_spec = [] * f._method_spec.append(self.spec) # <<<<<<<<<<<<<< * return f * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_method_spec); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_spec); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Append(__pyx_t_3, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":354 * f._method_spec = [] * f._method_spec.append(self.spec) * return f # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_f); __pyx_r = __pyx_v_f; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":347 * make_method._counter += 1 * * def __call__(self, f): # <<<<<<<<<<<<<< * # we can't access the Server object here, because at the time the * # decorator is run it doesn't even exist yet, so we store the */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyliblo3._liblo.make_method.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":363 * cdef list _keep_refs * * def __init__(self, reg_methods=True): # <<<<<<<<<<<<<< * self._keep_refs = [] * */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_11_ServerBase_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_11_ServerBase_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_reg_methods = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_reg_methods,0}; values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_True)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_reg_methods); if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 363, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_reg_methods = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 363, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase___init__(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self), __pyx_v_reg_methods); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_11_ServerBase___init__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_reg_methods) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":364 * * def __init__(self, reg_methods=True): * self._keep_refs = [] # <<<<<<<<<<<<<< * * if reg_methods: */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_keep_refs); __Pyx_DECREF(__pyx_v_self->_keep_refs); __pyx_v_self->_keep_refs = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":366 * self._keep_refs = [] * * if reg_methods: # <<<<<<<<<<<<<< * self.register_methods() * */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_reg_methods); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 366, __pyx_L1_error) if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":367 * * if reg_methods: * self.register_methods() # <<<<<<<<<<<<<< * * cdef _check(self): */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_register_methods); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":366 * self._keep_refs = [] * * if reg_methods: # <<<<<<<<<<<<<< * self.register_methods() * */ } /* "pyliblo3/_liblo.pyx":363 * cdef list _keep_refs * * def __init__(self, reg_methods=True): # <<<<<<<<<<<<<< * self._keep_refs = [] * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":369 * self.register_methods() * * cdef _check(self): # <<<<<<<<<<<<<< * if self._server == NULL: * raise RuntimeError("Server method called after free()") */ static PyObject *__pyx_f_8pyliblo3_6_liblo_11_ServerBase__check(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { 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("_check", 1); /* "pyliblo3/_liblo.pyx":370 * * cdef _check(self): * if self._server == NULL: # <<<<<<<<<<<<<< * raise RuntimeError("Server method called after free()") * */ __pyx_t_1 = (__pyx_v_self->_server == NULL); if (unlikely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":371 * cdef _check(self): * if self._server == NULL: * raise RuntimeError("Server method called after free()") # <<<<<<<<<<<<<< * * def register_methods(self, obj=None): */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 371, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":370 * * cdef _check(self): * if self._server == NULL: # <<<<<<<<<<<<<< * raise RuntimeError("Server method called after free()") * */ } /* "pyliblo3/_liblo.pyx":369 * self.register_methods() * * cdef _check(self): # <<<<<<<<<<<<<< * if self._server == NULL: * raise RuntimeError("Server method called after free()") */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase._check", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":373 * raise RuntimeError("Server method called after free()") * * def register_methods(self, obj=None): # <<<<<<<<<<<<<< * """ * Called internally during init if reg_methods is True */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_3register_methods(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_2register_methods, "_ServerBase.register_methods(self, obj=None)\n\n Called internally during init if reg_methods is True\n\n Args:\n obj: The object that implements the OSC callbacks to be registered.\n By default this is the server object itself.\n\n This function is usually called automatically by the server's\n constructor, unless its *reg_methods* parameter was set to `False`.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_3register_methods = {"register_methods", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_3register_methods, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_2register_methods}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_3register_methods(PyObject *__pyx_v_self, #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_obj = 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("register_methods (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_obj,0}; values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj); if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 373, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "register_methods") < 0)) __PYX_ERR(0, 373, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_obj = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("register_methods", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 373, __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("pyliblo3._liblo._ServerBase.register_methods", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_2register_methods(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self), __pyx_v_obj); /* 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; } /* "pyliblo3/_liblo.pyx":393 * methods.append(struct(spec=spec, name=m[1])) * # sort by counter * methods.sort(key=lambda x: x.spec.counter) # <<<<<<<<<<<<<< * for e in methods: * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_16register_methods_lambda(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_16register_methods_lambda = {"lambda", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_16register_methods_lambda, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_16register_methods_lambda(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_x = 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("lambda (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_x,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_x)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 393, __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, "lambda") < 0)) __PYX_ERR(0, 393, __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_x = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 393, __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("pyliblo3._liblo._ServerBase.register_methods.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self, __pyx_v_x); /* 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_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("lambda", 1); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_spec); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_counter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.register_methods.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":373 * raise RuntimeError("Server method called after free()") * * def register_methods(self, obj=None): # <<<<<<<<<<<<<< * """ * Called internally during init if reg_methods is True */ static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_2register_methods(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_obj) { PyObject *__pyx_v_methods = NULL; PyObject *__pyx_v_m = NULL; PyObject *__pyx_v_spec = NULL; PyObject *__pyx_v_e = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); Py_ssize_t __pyx_t_8; PyObject *(*__pyx_t_9)(PyObject *); PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("register_methods", 0); __Pyx_INCREF(__pyx_v_obj); /* "pyliblo3/_liblo.pyx":384 * constructor, unless its *reg_methods* parameter was set to `False`. * """ * if obj == None: # <<<<<<<<<<<<<< * obj = self * # find and register methods that were defined using decorators */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_obj, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 384, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":385 * """ * if obj == None: * obj = self # <<<<<<<<<<<<<< * # find and register methods that were defined using decorators * methods = [] */ __Pyx_INCREF((PyObject *)__pyx_v_self); __Pyx_DECREF_SET(__pyx_v_obj, ((PyObject *)__pyx_v_self)); /* "pyliblo3/_liblo.pyx":384 * constructor, unless its *reg_methods* parameter was set to `False`. * """ * if obj == None: # <<<<<<<<<<<<<< * obj = self * # find and register methods that were defined using decorators */ } /* "pyliblo3/_liblo.pyx":387 * obj = self * # find and register methods that were defined using decorators * methods = [] # <<<<<<<<<<<<<< * for m in _inspect.getmembers(obj): * if hasattr(m[1], '_method_spec'): */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_methods = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":388 * # find and register methods that were defined using decorators * methods = [] * for m in _inspect.getmembers(obj): # <<<<<<<<<<<<<< * if hasattr(m[1], '_method_spec'): * for spec in m[1]._method_spec: */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_inspect); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_getmembers); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_obj}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { __pyx_t_6 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 388, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_4))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 388, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 388, __pyx_L1_error) #else __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 388, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 388, __pyx_L1_error) #else __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 388, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_1); } __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":389 * methods = [] * for m in _inspect.getmembers(obj): * if hasattr(m[1], '_method_spec'): # <<<<<<<<<<<<<< * for spec in m[1]._method_spec: * methods.append(struct(spec=spec, name=m[1])) */ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_m, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_HasAttr(__pyx_t_1, __pyx_n_s_method_spec); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":390 * for m in _inspect.getmembers(obj): * if hasattr(m[1], '_method_spec'): * for spec in m[1]._method_spec: # <<<<<<<<<<<<<< * methods.append(struct(spec=spec, name=m[1])) * # sort by counter */ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_m, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_method_spec); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0; __pyx_t_9 = NULL; } else { __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 390, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { if (likely(!__pyx_t_9)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 390, __pyx_L1_error) #endif if (__pyx_t_8 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 390, __pyx_L1_error) #else __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 390, __pyx_L1_error) #endif if (__pyx_t_8 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 390, __pyx_L1_error) #else __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_9(__pyx_t_1); if (unlikely(!__pyx_t_3)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 390, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_3); } __Pyx_XDECREF_SET(__pyx_v_spec, __pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":391 * if hasattr(m[1], '_method_spec'): * for spec in m[1]._method_spec: * methods.append(struct(spec=spec, name=m[1])) # <<<<<<<<<<<<<< * # sort by counter * methods.sort(key=lambda x: x.spec.counter) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_struct); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_spec, __pyx_v_spec) < 0) __PYX_ERR(0, 391, __pyx_L1_error) __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_m, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_name, __pyx_t_11) < 0) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_methods, __pyx_t_11); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; /* "pyliblo3/_liblo.pyx":390 * for m in _inspect.getmembers(obj): * if hasattr(m[1], '_method_spec'): * for spec in m[1]._method_spec: # <<<<<<<<<<<<<< * methods.append(struct(spec=spec, name=m[1])) * # sort by counter */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":389 * methods = [] * for m in _inspect.getmembers(obj): * if hasattr(m[1], '_method_spec'): # <<<<<<<<<<<<<< * for spec in m[1]._method_spec: * methods.append(struct(spec=spec, name=m[1])) */ } /* "pyliblo3/_liblo.pyx":388 * # find and register methods that were defined using decorators * methods = [] * for m in _inspect.getmembers(obj): # <<<<<<<<<<<<<< * if hasattr(m[1], '_method_spec'): * for spec in m[1]._method_spec: */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":393 * methods.append(struct(spec=spec, name=m[1])) * # sort by counter * methods.sort(key=lambda x: x.spec.counter) # <<<<<<<<<<<<<< * for e in methods: * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_methods, __pyx_n_s_sort); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_16register_methods_lambda, 0, __pyx_n_s_register_methods_locals_lambda, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_key, __pyx_t_11) < 0) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; /* "pyliblo3/_liblo.pyx":394 * # sort by counter * methods.sort(key=lambda x: x.spec.counter) * for e in methods: # <<<<<<<<<<<<<< * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) * */ __pyx_t_11 = __pyx_v_methods; __Pyx_INCREF(__pyx_t_11); __pyx_t_6 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_11); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 394, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 394, __pyx_L1_error) #else __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif __Pyx_XDECREF_SET(__pyx_v_e, __pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":395 * methods.sort(key=lambda x: x.spec.counter) * for e in methods: * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) # <<<<<<<<<<<<<< * * def get_url(self): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_method); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_spec); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_spec); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_types); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_name); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_spec); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_n_s_user_data); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __pyx_t_14 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[5] = {__pyx_t_14, __pyx_t_3, __pyx_t_13, __pyx_t_10, __pyx_t_15}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 4+__pyx_t_5); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":394 * # sort by counter * methods.sort(key=lambda x: x.spec.counter) * for e in methods: # <<<<<<<<<<<<<< * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) * */ } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; /* "pyliblo3/_liblo.pyx":373 * raise RuntimeError("Server method called after free()") * * def register_methods(self, obj=None): # <<<<<<<<<<<<<< * """ * Called internally during init if reg_methods is True */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_15); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.register_methods", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_methods); __Pyx_XDECREF(__pyx_v_m); __Pyx_XDECREF(__pyx_v_spec); __Pyx_XDECREF(__pyx_v_e); __Pyx_XDECREF(__pyx_v_obj); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":397 * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) * * def get_url(self): # <<<<<<<<<<<<<< * """ * Returns the url of the server */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_5get_url(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_4get_url, "_ServerBase.get_url(self)\n\n Returns the url of the server\n\n Returns:\n (str) url of the server\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_5get_url = {"get_url", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_5get_url, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_4get_url}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_5get_url(PyObject *__pyx_v_self, #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_url (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_url", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_url", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_4get_url(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_4get_url(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { char *__pyx_v_tmp; PyObject *__pyx_v_r = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_url", 1); /* "pyliblo3/_liblo.pyx":404 * (str) url of the server * """ * self._check() # <<<<<<<<<<<<<< * cdef char *tmp = lo_server_get_url(self._server) * cdef object r = tmp */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self->__pyx_vtab)->_check(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 404, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":405 * """ * self._check() * cdef char *tmp = lo_server_get_url(self._server) # <<<<<<<<<<<<<< * cdef object r = tmp * free(tmp) */ __pyx_v_tmp = lo_server_get_url(__pyx_v_self->_server); /* "pyliblo3/_liblo.pyx":406 * self._check() * cdef char *tmp = lo_server_get_url(self._server) * cdef object r = tmp # <<<<<<<<<<<<<< * free(tmp) * return _decode(r) */ __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_tmp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_r = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":407 * cdef char *tmp = lo_server_get_url(self._server) * cdef object r = tmp * free(tmp) # <<<<<<<<<<<<<< * return _decode(r) * */ free(__pyx_v_tmp); /* "pyliblo3/_liblo.pyx":408 * cdef object r = tmp * free(tmp) * return _decode(r) # <<<<<<<<<<<<<< * * def get_port(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_v_r); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":397 * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) * * def get_url(self): # <<<<<<<<<<<<<< * """ * Returns the url of the server */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.get_url", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_r); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":410 * return _decode(r) * * def get_port(self): # <<<<<<<<<<<<<< * """ * Returns the port number of this server */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_7get_port(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_6get_port, "_ServerBase.get_port(self)\n\n Returns the port number of this server\n\n Returns:\n (int) port number\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_7get_port = {"get_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_7get_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_6get_port}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_7get_port(PyObject *__pyx_v_self, #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_port (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_port", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_port", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_6get_port(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_6get_port(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_port", 1); /* "pyliblo3/_liblo.pyx":417 * (int) port number * """ * self._check() # <<<<<<<<<<<<<< * return lo_server_get_port(self._server) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self->__pyx_vtab)->_check(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":418 * """ * self._check() * return lo_server_get_port(self._server) # <<<<<<<<<<<<<< * * def get_protocol(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(lo_server_get_port(__pyx_v_self->_server)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":410 * return _decode(r) * * def get_port(self): # <<<<<<<<<<<<<< * """ * Returns the port number of this server */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.get_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":420 * return lo_server_get_port(self._server) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * Returns the protocol of this server, as an int */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_9get_protocol(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_8get_protocol, "_ServerBase.get_protocol(self)\n\n Returns the protocol of this server, as an int\n\n This will be one of `LO_TCP`, `LO_TCP` or `LO_UNIX`\n\n Returns:\n (int) the protocol as an int\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_9get_protocol = {"get_protocol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_9get_protocol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_8get_protocol}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_9get_protocol(PyObject *__pyx_v_self, #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_protocol (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_protocol", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_protocol", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_8get_protocol(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_8get_protocol(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_protocol", 1); /* "pyliblo3/_liblo.pyx":429 * (int) the protocol as an int * """ * self._check() # <<<<<<<<<<<<<< * return lo_server_get_protocol(self._server) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self->__pyx_vtab)->_check(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":430 * """ * self._check() * return lo_server_get_protocol(self._server) # <<<<<<<<<<<<<< * * def fileno(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(lo_server_get_protocol(__pyx_v_self->_server)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":420 * return lo_server_get_port(self._server) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * Returns the protocol of this server, as an int */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.get_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":432 * return lo_server_get_protocol(self._server) * * def fileno(self): # <<<<<<<<<<<<<< * """ * Return the file descriptor of the server socket */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_11fileno(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_10fileno, "_ServerBase.fileno(self)\n\n Return the file descriptor of the server socket\n\n Returns:\n (int) the file descriptor, or -1 if not supported by the underlying server protocol\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_11fileno = {"fileno", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_11fileno, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_10fileno}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_11fileno(PyObject *__pyx_v_self, #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("fileno (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("fileno", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "fileno", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_10fileno(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_10fileno(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__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("fileno", 1); /* "pyliblo3/_liblo.pyx":439 * (int) the file descriptor, or -1 if not supported by the underlying server protocol * """ * self._check() # <<<<<<<<<<<<<< * return lo_server_get_socket_fd(self._server) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self->__pyx_vtab)->_check(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":440 * """ * self._check() * return lo_server_get_socket_fd(self._server) # <<<<<<<<<<<<<< * * def add_method(self, str path, str typespec, func, user_data=None): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(lo_server_get_socket_fd(__pyx_v_self->_server)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":432 * return lo_server_get_protocol(self._server) * * def fileno(self): # <<<<<<<<<<<<<< * """ * Return the file descriptor of the server socket */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.fileno", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":442 * return lo_server_get_socket_fd(self._server) * * def add_method(self, str path, str typespec, func, user_data=None): # <<<<<<<<<<<<<< * """ * Register a callback for OSC messages with matching path and argument types. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_13add_method(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_12add_method, "_ServerBase.add_method(self, str path, str typespec, func, user_data=None)\n\n Register a callback for OSC messages with matching path and argument types.\n\n Args:\n path (str): the message path to be handled by the registered method.\n `None` may be used as a wildcard to match any OSC message.\n typespec (str): the argument types to be handled by the registered method.\n `None` may be used as a wildcard to match any OSC message.\n func: the callback function. This may be a global function, a class\n method, or any other callable object, pyliblo will know what\n to do either way.\n user_data: An arbitrary object that will be passed on to *func* every time\n a matching message is received.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_13add_method = {"add_method", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_13add_method, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_12add_method}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_13add_method(PyObject *__pyx_v_self, #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_path = 0; PyObject *__pyx_v_typespec = 0; PyObject *__pyx_v_func = 0; PyObject *__pyx_v_user_data = 0; #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("add_method (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_path,&__pyx_n_s_typespec,&__pyx_n_s_func_3,&__pyx_n_s_user_data,0}; values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 442, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_typespec)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 442, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("add_method", 0, 3, 4, 1); __PYX_ERR(0, 442, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_func_3)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 442, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("add_method", 0, 3, 4, 2); __PYX_ERR(0, 442, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_user_data); if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 442, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add_method") < 0)) __PYX_ERR(0, 442, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 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; } } __pyx_v_path = ((PyObject*)values[0]); __pyx_v_typespec = ((PyObject*)values[1]); __pyx_v_func = values[2]; __pyx_v_user_data = values[3]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("add_method", 0, 3, 4, __pyx_nargs); __PYX_ERR(0, 442, __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("pyliblo3._liblo._ServerBase.add_method", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_path), (&PyString_Type), 1, "path", 1))) __PYX_ERR(0, 442, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_typespec), (&PyString_Type), 1, "typespec", 1))) __PYX_ERR(0, 442, __pyx_L1_error) __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_12add_method(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self), __pyx_v_path, __pyx_v_typespec, __pyx_v_func, __pyx_v_user_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; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_12add_method(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_typespec, PyObject *__pyx_v_func, PyObject *__pyx_v_user_data) { char *__pyx_v_p; char *__pyx_v_t; PyObject *__pyx_v_s = NULL; PyObject *__pyx_v_s2 = NULL; struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v_cb = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_method", 1); /* "pyliblo3/_liblo.pyx":460 * cdef char *t * * if isinstance(path, (bytes, unicode)): # <<<<<<<<<<<<<< * s = _encode(path) * p = s */ __pyx_t_2 = PyBytes_Check(__pyx_v_path); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = PyUnicode_Check(__pyx_v_path); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":461 * * if isinstance(path, (bytes, unicode)): * s = _encode(path) # <<<<<<<<<<<<<< * p = s * elif path is None: */ __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_s = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":462 * if isinstance(path, (bytes, unicode)): * s = _encode(path) * p = s # <<<<<<<<<<<<<< * elif path is None: * p = NULL */ if (unlikely(__pyx_v_s == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 462, __pyx_L1_error) } __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(0, 462, __pyx_L1_error) __pyx_v_p = __pyx_t_4; /* "pyliblo3/_liblo.pyx":460 * cdef char *t * * if isinstance(path, (bytes, unicode)): # <<<<<<<<<<<<<< * s = _encode(path) * p = s */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":463 * s = _encode(path) * p = s * elif path is None: # <<<<<<<<<<<<<< * p = NULL * else: */ __pyx_t_1 = (__pyx_v_path == ((PyObject*)Py_None)); if (likely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":464 * p = s * elif path is None: * p = NULL # <<<<<<<<<<<<<< * else: * raise TypeError("path must be a string or None") */ __pyx_v_p = NULL; /* "pyliblo3/_liblo.pyx":463 * s = _encode(path) * p = s * elif path is None: # <<<<<<<<<<<<<< * p = NULL * else: */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":466 * p = NULL * else: * raise TypeError("path must be a string or None") # <<<<<<<<<<<<<< * * if isinstance(typespec, (bytes, unicode)): */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 466, __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, 466, __pyx_L1_error) } __pyx_L3:; /* "pyliblo3/_liblo.pyx":468 * raise TypeError("path must be a string or None") * * if isinstance(typespec, (bytes, unicode)): # <<<<<<<<<<<<<< * s2 = _encode(typespec) * t = s2 */ __pyx_t_2 = PyBytes_Check(__pyx_v_typespec); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } __pyx_t_2 = PyUnicode_Check(__pyx_v_typespec); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":469 * * if isinstance(typespec, (bytes, unicode)): * s2 = _encode(typespec) # <<<<<<<<<<<<<< * t = s2 * elif typespec is None: */ __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_typespec); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_s2 = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":470 * if isinstance(typespec, (bytes, unicode)): * s2 = _encode(typespec) * t = s2 # <<<<<<<<<<<<<< * elif typespec is None: * t = NULL */ if (unlikely(__pyx_v_s2 == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 470, __pyx_L1_error) } __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_s2); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(0, 470, __pyx_L1_error) __pyx_v_t = __pyx_t_4; /* "pyliblo3/_liblo.pyx":468 * raise TypeError("path must be a string or None") * * if isinstance(typespec, (bytes, unicode)): # <<<<<<<<<<<<<< * s2 = _encode(typespec) * t = s2 */ goto __pyx_L6; } /* "pyliblo3/_liblo.pyx":471 * s2 = _encode(typespec) * t = s2 * elif typespec is None: # <<<<<<<<<<<<<< * t = NULL * else: */ __pyx_t_1 = (__pyx_v_typespec == ((PyObject*)Py_None)); if (likely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":472 * t = s2 * elif typespec is None: * t = NULL # <<<<<<<<<<<<<< * else: * raise TypeError("typespec must be a string or None") */ __pyx_v_t = NULL; /* "pyliblo3/_liblo.pyx":471 * s2 = _encode(typespec) * t = s2 * elif typespec is None: # <<<<<<<<<<<<<< * t = NULL * else: */ goto __pyx_L6; } /* "pyliblo3/_liblo.pyx":474 * t = NULL * else: * raise TypeError("typespec must be a string or None") # <<<<<<<<<<<<<< * * self._check() */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __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, 474, __pyx_L1_error) } __pyx_L6:; /* "pyliblo3/_liblo.pyx":476 * raise TypeError("typespec must be a string or None") * * self._check() # <<<<<<<<<<<<<< * * # use a weak reference if func is a method, to avoid circular */ __pyx_t_3 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self->__pyx_vtab)->_check(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":483 * # class) * # cb = struct(func=_weakref_method(func), user_data=user_data) * cb = Callback(func, user_data) # <<<<<<<<<<<<<< * # keep a reference to the callback data around * self._keep_refs.append(cb) */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_func); __Pyx_GIVEREF(__pyx_v_func); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_func)) __PYX_ERR(0, 483, __pyx_L1_error); __Pyx_INCREF(__pyx_v_user_data); __Pyx_GIVEREF(__pyx_v_user_data); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_user_data)) __PYX_ERR(0, 483, __pyx_L1_error); __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Callback), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_cb = ((struct __pyx_obj_8pyliblo3_6_liblo_Callback *)__pyx_t_5); __pyx_t_5 = 0; /* "pyliblo3/_liblo.pyx":485 * cb = Callback(func, user_data) * # keep a reference to the callback data around * self._keep_refs.append(cb) # <<<<<<<<<<<<<< * * lo_server_add_method(self._server, p, t, _msg_callback, cb) */ if (unlikely(__pyx_v_self->_keep_refs == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); __PYX_ERR(0, 485, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_self->_keep_refs, ((PyObject *)__pyx_v_cb)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 485, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":487 * self._keep_refs.append(cb) * * lo_server_add_method(self._server, p, t, _msg_callback, cb) # <<<<<<<<<<<<<< * * def del_method(self, path, typespec=None): */ (void)(lo_server_add_method(__pyx_v_self->_server, __pyx_v_p, __pyx_v_t, __pyx_f_8pyliblo3_6_liblo__msg_callback, ((void *)__pyx_v_cb))); /* "pyliblo3/_liblo.pyx":442 * return lo_server_get_socket_fd(self._server) * * def add_method(self, str path, str typespec, func, user_data=None): # <<<<<<<<<<<<<< * """ * Register a callback for OSC messages with matching path and argument types. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.add_method", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_s); __Pyx_XDECREF(__pyx_v_s2); __Pyx_XDECREF((PyObject *)__pyx_v_cb); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":489 * lo_server_add_method(self._server, p, t, _msg_callback, cb) * * def del_method(self, path, typespec=None): # <<<<<<<<<<<<<< * """ * Delete a callback function */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_15del_method(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_14del_method, "_ServerBase.del_method(self, path, typespec=None)\n\n Delete a callback function\n\n Delete a callback function. For both *path* and *typespec*, `None`\n may be used as a wildcard.\n\n Args:\n path (str | None): the method to delete\n typespec (str | None): the typespec to match, or None to delete any\n method matching the given path\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_15del_method = {"del_method", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_15del_method, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_14del_method}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_15del_method(PyObject *__pyx_v_self, #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_path = 0; PyObject *__pyx_v_typespec = 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("del_method (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_path,&__pyx_n_s_typespec,0}; values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_typespec); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "del_method") < 0)) __PYX_ERR(0, 489, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_typespec = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("del_method", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 489, __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("pyliblo3._liblo._ServerBase.del_method", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_14del_method(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self), __pyx_v_path, __pyx_v_typespec); /* 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_8pyliblo3_6_liblo_11_ServerBase_14del_method(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_typespec) { char *__pyx_v_p; char *__pyx_v_t; PyObject *__pyx_v_s = NULL; PyObject *__pyx_v_s2 = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; char *__pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("del_method", 1); /* "pyliblo3/_liblo.pyx":504 * cdef char *t * * if isinstance(path, (bytes, unicode)): # <<<<<<<<<<<<<< * s = _encode(path) * p = s */ __pyx_t_2 = PyBytes_Check(__pyx_v_path); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = PyUnicode_Check(__pyx_v_path); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":505 * * if isinstance(path, (bytes, unicode)): * s = _encode(path) # <<<<<<<<<<<<<< * p = s * elif path == None: */ __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_s = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":506 * if isinstance(path, (bytes, unicode)): * s = _encode(path) * p = s # <<<<<<<<<<<<<< * elif path == None: * p = NULL */ if (unlikely(__pyx_v_s == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 506, __pyx_L1_error) } __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) __pyx_v_p = __pyx_t_4; /* "pyliblo3/_liblo.pyx":504 * cdef char *t * * if isinstance(path, (bytes, unicode)): # <<<<<<<<<<<<<< * s = _encode(path) * p = s */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":507 * s = _encode(path) * p = s * elif path == None: # <<<<<<<<<<<<<< * p = NULL * else: */ __pyx_t_3 = PyObject_RichCompare(__pyx_v_path, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 507, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":508 * p = s * elif path == None: * p = NULL # <<<<<<<<<<<<<< * else: * raise TypeError("path must be a string or None") */ __pyx_v_p = NULL; /* "pyliblo3/_liblo.pyx":507 * s = _encode(path) * p = s * elif path == None: # <<<<<<<<<<<<<< * p = NULL * else: */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":510 * p = NULL * else: * raise TypeError("path must be a string or None") # <<<<<<<<<<<<<< * * if isinstance(typespec, (bytes, unicode)): */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 510, __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, 510, __pyx_L1_error) } __pyx_L3:; /* "pyliblo3/_liblo.pyx":512 * raise TypeError("path must be a string or None") * * if isinstance(typespec, (bytes, unicode)): # <<<<<<<<<<<<<< * s2 = _encode(typespec) * t = s2 */ __pyx_t_2 = PyBytes_Check(__pyx_v_typespec); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } __pyx_t_2 = PyUnicode_Check(__pyx_v_typespec); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":513 * * if isinstance(typespec, (bytes, unicode)): * s2 = _encode(typespec) # <<<<<<<<<<<<<< * t = s2 * elif typespec == None: */ __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_typespec); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_s2 = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":514 * if isinstance(typespec, (bytes, unicode)): * s2 = _encode(typespec) * t = s2 # <<<<<<<<<<<<<< * elif typespec == None: * t = NULL */ if (unlikely(__pyx_v_s2 == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 514, __pyx_L1_error) } __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_s2); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L1_error) __pyx_v_t = __pyx_t_4; /* "pyliblo3/_liblo.pyx":512 * raise TypeError("path must be a string or None") * * if isinstance(typespec, (bytes, unicode)): # <<<<<<<<<<<<<< * s2 = _encode(typespec) * t = s2 */ goto __pyx_L6; } /* "pyliblo3/_liblo.pyx":515 * s2 = _encode(typespec) * t = s2 * elif typespec == None: # <<<<<<<<<<<<<< * t = NULL * else: */ __pyx_t_3 = PyObject_RichCompare(__pyx_v_typespec, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 515, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":516 * t = s2 * elif typespec == None: * t = NULL # <<<<<<<<<<<<<< * else: * raise TypeError("typespec must be a string or None") */ __pyx_v_t = NULL; /* "pyliblo3/_liblo.pyx":515 * s2 = _encode(typespec) * t = s2 * elif typespec == None: # <<<<<<<<<<<<<< * t = NULL * else: */ goto __pyx_L6; } /* "pyliblo3/_liblo.pyx":518 * t = NULL * else: * raise TypeError("typespec must be a string or None") # <<<<<<<<<<<<<< * * self._check() */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __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, 518, __pyx_L1_error) } __pyx_L6:; /* "pyliblo3/_liblo.pyx":520 * raise TypeError("typespec must be a string or None") * * self._check() # <<<<<<<<<<<<<< * lo_server_del_method(self._server, p, t) * */ __pyx_t_3 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self->__pyx_vtab)->_check(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":521 * * self._check() * lo_server_del_method(self._server, p, t) # <<<<<<<<<<<<<< * * def add_bundle_handlers(self, start_handler, end_handler, user_data=None): */ lo_server_del_method(__pyx_v_self->_server, __pyx_v_p, __pyx_v_t); /* "pyliblo3/_liblo.pyx":489 * lo_server_add_method(self._server, p, t, _msg_callback, cb) * * def del_method(self, path, typespec=None): # <<<<<<<<<<<<<< * """ * Delete a callback function */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.del_method", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_s); __Pyx_XDECREF(__pyx_v_s2); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":523 * lo_server_del_method(self._server, p, t) * * def add_bundle_handlers(self, start_handler, end_handler, user_data=None): # <<<<<<<<<<<<<< * """ * Add bundle notification handlers. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_17add_bundle_handlers(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_16add_bundle_handlers, "_ServerBase.add_bundle_handlers(self, start_handler, end_handler, user_data=None)\n\n Add bundle notification handlers.\n\n Args:\n start_handler: a callback which fires when at the start of a bundle. This is\n called with the bundle's timestamp and user_data.\n end_handler: a callback which fires when at the end of a bundle. This is called\n with user_data.\n user_data: data to pass to the handlers.\n\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_17add_bundle_handlers = {"add_bundle_handlers", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_17add_bundle_handlers, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_16add_bundle_handlers}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_17add_bundle_handlers(PyObject *__pyx_v_self, #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_start_handler = 0; PyObject *__pyx_v_end_handler = 0; PyObject *__pyx_v_user_data = 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_bundle_handlers (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_start_handler,&__pyx_n_s_end_handler,&__pyx_n_s_user_data,0}; values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_start_handler)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_end_handler)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("add_bundle_handlers", 0, 2, 3, 1); __PYX_ERR(0, 523, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_user_data); if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add_bundle_handlers") < 0)) __PYX_ERR(0, 523, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_start_handler = values[0]; __pyx_v_end_handler = values[1]; __pyx_v_user_data = values[2]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("add_bundle_handlers", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 523, __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("pyliblo3._liblo._ServerBase.add_bundle_handlers", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_16add_bundle_handlers(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self), __pyx_v_start_handler, __pyx_v_end_handler, __pyx_v_user_data); /* 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_8pyliblo3_6_liblo_11_ServerBase_16add_bundle_handlers(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_start_handler, PyObject *__pyx_v_end_handler, PyObject *__pyx_v_user_data) { PyObject *__pyx_v_cb_data = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_bundle_handlers", 1); /* "pyliblo3/_liblo.pyx":535 * * """ * cb_data = struct(start_func=_weakref_method(start_handler), # <<<<<<<<<<<<<< * end_func=_weakref_method(end_handler), * user_data=user_data) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_struct); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_weakref_method); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_start_handler}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_start_func, __pyx_t_3) < 0) __PYX_ERR(0, 535, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":536 * """ * cb_data = struct(start_func=_weakref_method(start_handler), * end_func=_weakref_method(end_handler), # <<<<<<<<<<<<<< * user_data=user_data) * self._keep_refs.append(cb_data) */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_weakref_method); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_end_handler}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_end_func, __pyx_t_3) < 0) __PYX_ERR(0, 535, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":537 * cb_data = struct(start_func=_weakref_method(start_handler), * end_func=_weakref_method(end_handler), * user_data=user_data) # <<<<<<<<<<<<<< * self._keep_refs.append(cb_data) * */ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_user_data, __pyx_v_user_data) < 0) __PYX_ERR(0, 535, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":535 * * """ * cb_data = struct(start_func=_weakref_method(start_handler), # <<<<<<<<<<<<<< * end_func=_weakref_method(end_handler), * user_data=user_data) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_cb_data = __pyx_t_3; __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":538 * end_func=_weakref_method(end_handler), * user_data=user_data) * self._keep_refs.append(cb_data) # <<<<<<<<<<<<<< * * lo_server_add_bundle_handlers(self._server, _bundle_start_callback, */ if (unlikely(__pyx_v_self->_keep_refs == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); __PYX_ERR(0, 538, __pyx_L1_error) } __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_self->_keep_refs, __pyx_v_cb_data); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 538, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":540 * self._keep_refs.append(cb_data) * * lo_server_add_bundle_handlers(self._server, _bundle_start_callback, # <<<<<<<<<<<<<< * _bundle_end_callback, cb_data) * */ (void)(lo_server_add_bundle_handlers(__pyx_v_self->_server, __pyx_f_8pyliblo3_6_liblo__bundle_start_callback, __pyx_f_8pyliblo3_6_liblo__bundle_end_callback, ((void *)__pyx_v_cb_data))); /* "pyliblo3/_liblo.pyx":523 * lo_server_del_method(self._server, p, t) * * def add_bundle_handlers(self, start_handler, end_handler, user_data=None): # <<<<<<<<<<<<<< * """ * Add bundle notification handlers. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.add_bundle_handlers", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_cb_data); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":543 * _bundle_end_callback, cb_data) * * def send(self, target, *args): # <<<<<<<<<<<<<< * """ * Send a message or bundle from this server to the the given target. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_19send(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_11_ServerBase_18send, "_ServerBase.send(self, target, *args)\n\n Send a message or bundle from this server to the the given target.\n\n * `send(target, *messages)`\n * `send(target, path, *args)`\n\n Send a message or bundle from this server to the the given target.\n Arguments may be one or more `Message` or `Bundle`\n objects, or a single message given by its path and optional arguments.\n\n Args:\n target (Address | tuple[str, int] | str): the address to send the message to;\n an `Address` object, a port number, a `(hostname, port)` tuple, or a URL.\n messages (Message | Bundle): one or more objects of type `Message` or `Bundle`.\n path (str): the path of the message to be sent.\n\n Raises:\n AddressError: if the given target is invalid.\n IOError: if the message couldn't be sent.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_19send = {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_19send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_18send}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_19send(PyObject *__pyx_v_self, #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_target = 0; PyObject *__pyx_v_args = 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("send (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); __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); if (unlikely(!__pyx_v_args)) { __Pyx_RefNannyFinishContext(); return NULL; } __Pyx_GOTREF(__pyx_v_args); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_target,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { default: case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; } 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_target)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 543, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, used_pos_args, "send") < 0)) __PYX_ERR(0, 543, __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_target = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("send", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 543, __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_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.send", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_18send(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self), __pyx_v_target, __pyx_v_args); /* function exit code */ __Pyx_DECREF(__pyx_v_args); { 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_8pyliblo3_6_liblo_11_ServerBase_18send(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, PyObject *__pyx_v_target, PyObject *__pyx_v_args) { 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("send", 1); /* "pyliblo3/_liblo.pyx":564 * IOError: if the message couldn't be sent. * """ * self._check() # <<<<<<<<<<<<<< * _send(target, self, args) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self->__pyx_vtab)->_check(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 564, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":565 * """ * self._check() * _send(target, self, args) # <<<<<<<<<<<<<< * * property url: */ __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__send(__pyx_v_target, __pyx_v_self, __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":543 * _bundle_end_callback, cb_data) * * def send(self, target, *args): # <<<<<<<<<<<<<< * """ * Send a message or bundle from this server to the the given target. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.send", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":571 * The server's URL. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_url() * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_3url_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_3url_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_8pyliblo3_6_liblo_11_ServerBase_3url___get__(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_3url___get__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "pyliblo3/_liblo.pyx":572 * """ * def __get__(self): * return self.get_url() # <<<<<<<<<<<<<< * * property port: */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_url); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 572, __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; /* "pyliblo3/_liblo.pyx":571 * The server's URL. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_url() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.url.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":578 * The server's port number (int) * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_port() * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_4port_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_4port_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_8pyliblo3_6_liblo_11_ServerBase_4port___get__(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_4port___get__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "pyliblo3/_liblo.pyx":579 * """ * def __get__(self): * return self.get_port() # <<<<<<<<<<<<<< * * property protocol: */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_port); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 579, __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; /* "pyliblo3/_liblo.pyx":578 * The server's port number (int) * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_port() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.port.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":585 * The server's protocol (one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX`). * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_protocol() * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_8protocol_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_8protocol_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_8pyliblo3_6_liblo_11_ServerBase_8protocol___get__(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_8protocol___get__(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "pyliblo3/_liblo.pyx":586 * """ * def __get__(self): * return self.get_protocol() # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_protocol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 586, __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; /* "pyliblo3/_liblo.pyx":585 * The server's protocol (one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX`). * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_protocol() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.protocol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_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_8pyliblo3_6_liblo_11_ServerBase_20__reduce_cython__, "_ServerBase.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_21__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_20__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_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_8pyliblo3_6_liblo_11_ServerBase_20__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_11_ServerBase_20__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__server_cannot_be_converted, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_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_8pyliblo3_6_liblo_11_ServerBase_22__setstate_cython__, "_ServerBase.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_23__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_22__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_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); #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(2, 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(2, 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(2, 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("pyliblo3._liblo._ServerBase.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_11_ServerBase_22__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__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_8pyliblo3_6_liblo_11_ServerBase_22__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._server cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__server_cannot_be_converted, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo._ServerBase.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":608 * * """ * def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): # <<<<<<<<<<<<<< * cdef char *cs * */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_6Server_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_6Server_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_port = 0; PyObject *__pyx_v_proto = 0; PyObject *__pyx_v_reg_methods = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_port,&__pyx_n_s_proto,&__pyx_n_s_reg_methods,0}; values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); values[1] = __Pyx_Arg_NewRef_VARARGS(__pyx_k__4); values[2] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_True)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port); if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 608, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_proto); if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 608, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_reg_methods); if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 608, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 608, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_port = values[0]; __pyx_v_proto = values[1]; __pyx_v_reg_methods = values[2]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 3, __pyx_nargs); __PYX_ERR(0, 608, __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("pyliblo3._liblo.Server.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6Server___init__(((struct __pyx_obj_8pyliblo3_6_liblo_Server *)__pyx_v_self), __pyx_v_port, __pyx_v_proto, __pyx_v_reg_methods); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_6Server___init__(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self, PyObject *__pyx_v_port, PyObject *__pyx_v_proto, PyObject *__pyx_v_reg_methods) { char *__pyx_v_cs; PyObject *__pyx_v_p = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); __Pyx_INCREF(__pyx_v_proto); /* "pyliblo3/_liblo.pyx":611 * cdef char *cs * * if port != None: # <<<<<<<<<<<<<< * p = _encode(str(port)); * cs = p */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_port, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":612 * * if port != None: * p = _encode(str(port)); # <<<<<<<<<<<<<< * cs = p * else: */ __pyx_t_1 = __Pyx_PyObject_Str(__pyx_v_port); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_p = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":613 * if port != None: * p = _encode(str(port)); * cs = p # <<<<<<<<<<<<<< * else: * cs = NULL */ if (unlikely(__pyx_v_p == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 613, __pyx_L1_error) } __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_p); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(0, 613, __pyx_L1_error) __pyx_v_cs = __pyx_t_4; /* "pyliblo3/_liblo.pyx":611 * cdef char *cs * * if port != None: # <<<<<<<<<<<<<< * p = _encode(str(port)); * cs = p */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":615 * cs = p * else: * cs = NULL # <<<<<<<<<<<<<< * * if isinstance(proto, str): */ /*else*/ { __pyx_v_cs = NULL; } __pyx_L3:; /* "pyliblo3/_liblo.pyx":617 * cs = NULL * * if isinstance(proto, str): # <<<<<<<<<<<<<< * proto = _protostr_to_int(proto) * */ __pyx_t_2 = PyString_Check(__pyx_v_proto); if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":618 * * if isinstance(proto, str): * proto = _protostr_to_int(proto) # <<<<<<<<<<<<<< * * global __exception */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_protostr_to_int); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; __pyx_t_6 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_6 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_proto}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_proto, __pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":617 * cs = NULL * * if isinstance(proto, str): # <<<<<<<<<<<<<< * proto = _protostr_to_int(proto) * */ } /* "pyliblo3/_liblo.pyx":621 * * global __exception * __exception = None # <<<<<<<<<<<<<< * self._server = lo_server_new_with_proto(cs, proto, _err_handler) * if __exception: */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_exception, Py_None) < 0) __PYX_ERR(0, 621, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":622 * global __exception * __exception = None * self._server = lo_server_new_with_proto(cs, proto, _err_handler) # <<<<<<<<<<<<<< * if __exception: * raise __exception */ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_proto); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 622, __pyx_L1_error) __pyx_v_self->__pyx_base._server = lo_server_new_with_proto(__pyx_v_cs, __pyx_t_6, __pyx_f_8pyliblo3_6_liblo__err_handler); /* "pyliblo3/_liblo.pyx":623 * __exception = None * self._server = lo_server_new_with_proto(cs, proto, _err_handler) * if __exception: # <<<<<<<<<<<<<< * raise __exception * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_exception); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 623, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 623, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_2)) { /* "pyliblo3/_liblo.pyx":624 * self._server = lo_server_new_with_proto(cs, proto, _err_handler) * if __exception: * raise __exception # <<<<<<<<<<<<<< * * _ServerBase.__init__(self, reg_methods=reg_methods) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_exception); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 624, __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, 624, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":623 * __exception = None * self._server = lo_server_new_with_proto(cs, proto, _err_handler) * if __exception: # <<<<<<<<<<<<<< * raise __exception * */ } /* "pyliblo3/_liblo.pyx":626 * raise __exception * * _ServerBase.__init__(self, reg_methods=reg_methods) # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase), __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_self); __Pyx_GIVEREF((PyObject *)__pyx_v_self); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(0, 626, __pyx_L1_error); __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_reg_methods, __pyx_v_reg_methods) < 0) __PYX_ERR(0, 626, __pyx_L1_error) __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":608 * * """ * def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): # <<<<<<<<<<<<<< * cdef char *cs * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("pyliblo3._liblo.Server.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_p); __Pyx_XDECREF(__pyx_v_proto); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":628 * _ServerBase.__init__(self, reg_methods=reg_methods) * * def __dealloc__(self): # <<<<<<<<<<<<<< * self.free() * */ /* Python wrapper */ static void __pyx_pw_8pyliblo3_6_liblo_6Server_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_8pyliblo3_6_liblo_6Server_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_8pyliblo3_6_liblo_6Server_2__dealloc__(((struct __pyx_obj_8pyliblo3_6_liblo_Server *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_8pyliblo3_6_liblo_6Server_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self) { __Pyx_RefNannyDeclarations 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("__dealloc__", 1); /* "pyliblo3/_liblo.pyx":629 * * def __dealloc__(self): * self.free() # <<<<<<<<<<<<<< * * def free(self): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_free); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":628 * _ServerBase.__init__(self, reg_methods=reg_methods) * * def __dealloc__(self): # <<<<<<<<<<<<<< * self.free() * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyliblo3._liblo.Server.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pyliblo3/_liblo.pyx":631 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_5free(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_6Server_4free, "Server.free(self)\n\n Free the underlying server object and close its port.\n\n Note that this will also happen automatically when the server is deallocated.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6Server_5free = {"free", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_5free, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_4free}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_5free(PyObject *__pyx_v_self, #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("free (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("free", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "free", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6Server_4free(((struct __pyx_obj_8pyliblo3_6_liblo_Server *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Server_4free(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("free", 1); /* "pyliblo3/_liblo.pyx":637 * Note that this will also happen automatically when the server is deallocated. * """ * if self._server: # <<<<<<<<<<<<<< * lo_server_free(self._server) * self._server = NULL */ __pyx_t_1 = (__pyx_v_self->__pyx_base._server != 0); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":638 * """ * if self._server: * lo_server_free(self._server) # <<<<<<<<<<<<<< * self._server = NULL * */ lo_server_free(__pyx_v_self->__pyx_base._server); /* "pyliblo3/_liblo.pyx":639 * if self._server: * lo_server_free(self._server) * self._server = NULL # <<<<<<<<<<<<<< * * def recv(self, timeout=None): */ __pyx_v_self->__pyx_base._server = NULL; /* "pyliblo3/_liblo.pyx":637 * Note that this will also happen automatically when the server is deallocated. * """ * if self._server: # <<<<<<<<<<<<<< * lo_server_free(self._server) * self._server = NULL */ } /* "pyliblo3/_liblo.pyx":631 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":641 * self._server = NULL * * def recv(self, timeout=None): # <<<<<<<<<<<<<< * """ * Receive and dispatch one OSC message. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_7recv(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_6Server_6recv, "Server.recv(self, timeout=None)\n\n Receive and dispatch one OSC message.\n\n Blocking by default, unless *timeout* is specified.\n\n Args:\n timeout (int, float): Time in milliseconds after which the function returns if no\n messages have been received. May be 0, in which case the function always returns\n immediately, whether messages have been received or not.\n\n Returns:\n `True` if a message was received, otherwise `False`.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6Server_7recv = {"recv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_7recv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_6recv}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_7recv(PyObject *__pyx_v_self, #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_timeout = 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("recv (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_timeout,0}; values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout); if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "recv") < 0)) __PYX_ERR(0, 641, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_timeout = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("recv", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 641, __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("pyliblo3._liblo.Server.recv", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6Server_6recv(((struct __pyx_obj_8pyliblo3_6_liblo_Server *)__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; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Server_6recv(struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self, PyObject *__pyx_v_timeout) { int __pyx_v_t; int __pyx_v_r; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("recv", 1); /* "pyliblo3/_liblo.pyx":656 * """ * cdef int t, r * self._check() # <<<<<<<<<<<<<< * if timeout != None: * t = timeout */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo_Server *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._check(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":657 * cdef int t, r * self._check() * if timeout != None: # <<<<<<<<<<<<<< * t = timeout * with nogil: */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_timeout, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 657, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 657, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":658 * self._check() * if timeout != None: * t = timeout # <<<<<<<<<<<<<< * with nogil: * r = lo_server_recv_noblock(self._server, t) */ __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_timeout); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 658, __pyx_L1_error) __pyx_v_t = __pyx_t_3; /* "pyliblo3/_liblo.pyx":659 * if timeout != None: * t = timeout * with nogil: # <<<<<<<<<<<<<< * r = lo_server_recv_noblock(self._server, t) * return r and True or False */ { #ifdef WITH_THREAD PyThreadState *_save; _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyliblo3/_liblo.pyx":660 * t = timeout * with nogil: * r = lo_server_recv_noblock(self._server, t) # <<<<<<<<<<<<<< * return r and True or False * else: */ __pyx_v_r = lo_server_recv_noblock(__pyx_v_self->__pyx_base._server, __pyx_v_t); } /* "pyliblo3/_liblo.pyx":659 * if timeout != None: * t = timeout * with nogil: # <<<<<<<<<<<<<< * r = lo_server_recv_noblock(self._server, t) * return r and True or False */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "pyliblo3/_liblo.pyx":661 * with nogil: * r = lo_server_recv_noblock(self._server, t) * return r and True or False # <<<<<<<<<<<<<< * else: * with nogil: */ __Pyx_XDECREF(__pyx_r); if (!__pyx_v_r) { goto __pyx_L8_next_or; } else { } if (!1) { } else { __pyx_t_4 = __Pyx_PyBool_FromLong(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L7_bool_binop_done; } __pyx_L8_next_or:; __pyx_t_4 = __Pyx_PyBool_FromLong(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __pyx_t_4; __pyx_t_4 = 0; __pyx_L7_bool_binop_done:; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":657 * cdef int t, r * self._check() * if timeout != None: # <<<<<<<<<<<<<< * t = timeout * with nogil: */ } /* "pyliblo3/_liblo.pyx":663 * return r and True or False * else: * with nogil: # <<<<<<<<<<<<<< * lo_server_recv(self._server) * return True */ /*else*/ { { #ifdef WITH_THREAD PyThreadState *_save; _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyliblo3/_liblo.pyx":664 * else: * with nogil: * lo_server_recv(self._server) # <<<<<<<<<<<<<< * return True * */ (void)(lo_server_recv(__pyx_v_self->__pyx_base._server)); } /* "pyliblo3/_liblo.pyx":663 * return r and True or False * else: * with nogil: # <<<<<<<<<<<<<< * lo_server_recv(self._server) * return True */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L12; } __pyx_L12:; } } /* "pyliblo3/_liblo.pyx":665 * with nogil: * lo_server_recv(self._server) * return True # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; } /* "pyliblo3/_liblo.pyx":641 * self._server = NULL * * def recv(self, timeout=None): # <<<<<<<<<<<<<< * """ * Receive and dispatch one OSC message. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyliblo3._liblo.Server.recv", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_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_8pyliblo3_6_liblo_6Server_8__reduce_cython__, "Server.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6Server_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_8__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_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_8pyliblo3_6_liblo_6Server_8__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Server *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Server_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__server_cannot_be_converted, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Server.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_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_8pyliblo3_6_liblo_6Server_10__setstate_cython__, "Server.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6Server_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_10__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Server_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); #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(2, 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(2, 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(2, 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("pyliblo3._liblo.Server.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6Server_10__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Server *)__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_8pyliblo3_6_liblo_6Server_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Server *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._server cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__server_cannot_be_converted, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Server.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":699 * cdef lo_server_thread _server_thread * * def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): # <<<<<<<<<<<<<< * cdef char *cs * */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_12ServerThread_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_12ServerThread_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_port = 0; PyObject *__pyx_v_proto = 0; PyObject *__pyx_v_reg_methods = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_port,&__pyx_n_s_proto,&__pyx_n_s_reg_methods,0}; values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); values[1] = __Pyx_Arg_NewRef_VARARGS(__pyx_k__5); values[2] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_True)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port); if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 699, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_proto); if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 699, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_reg_methods); if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 699, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 699, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_port = values[0]; __pyx_v_proto = values[1]; __pyx_v_reg_methods = values[2]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 3, __pyx_nargs); __PYX_ERR(0, 699, __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("pyliblo3._liblo.ServerThread.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_12ServerThread___init__(((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self), __pyx_v_port, __pyx_v_proto, __pyx_v_reg_methods); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_12ServerThread___init__(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self, PyObject *__pyx_v_port, PyObject *__pyx_v_proto, PyObject *__pyx_v_reg_methods) { char *__pyx_v_cs; PyObject *__pyx_v_p = NULL; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; char *__pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":702 * cdef char *cs * * if port != None: # <<<<<<<<<<<<<< * p = _encode(str(port)); * cs = p */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_port, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 702, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 702, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":703 * * if port != None: * p = _encode(str(port)); # <<<<<<<<<<<<<< * cs = p * else: */ __pyx_t_1 = __Pyx_PyObject_Str(__pyx_v_port); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_p = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":704 * if port != None: * p = _encode(str(port)); * cs = p # <<<<<<<<<<<<<< * else: * cs = NULL */ if (unlikely(__pyx_v_p == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 704, __pyx_L1_error) } __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_p); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(0, 704, __pyx_L1_error) __pyx_v_cs = __pyx_t_4; /* "pyliblo3/_liblo.pyx":702 * cdef char *cs * * if port != None: # <<<<<<<<<<<<<< * p = _encode(str(port)); * cs = p */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":706 * cs = p * else: * cs = NULL # <<<<<<<<<<<<<< * * # make sure python can handle threading */ /*else*/ { __pyx_v_cs = NULL; } __pyx_L3:; /* "pyliblo3/_liblo.pyx":709 * * # make sure python can handle threading * PyEval_InitThreads() # <<<<<<<<<<<<<< * * global __exception */ PyEval_InitThreads(); /* "pyliblo3/_liblo.pyx":712 * * global __exception * __exception = None # <<<<<<<<<<<<<< * self._server_thread = lo_server_thread_new_with_proto(cs, proto, _err_handler) * if __exception: */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_exception, Py_None) < 0) __PYX_ERR(0, 712, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":713 * global __exception * __exception = None * self._server_thread = lo_server_thread_new_with_proto(cs, proto, _err_handler) # <<<<<<<<<<<<<< * if __exception: * raise __exception */ __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_proto); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 713, __pyx_L1_error) __pyx_v_self->_server_thread = lo_server_thread_new_with_proto(__pyx_v_cs, __pyx_t_5, __pyx_f_8pyliblo3_6_liblo__err_handler); /* "pyliblo3/_liblo.pyx":714 * __exception = None * self._server_thread = lo_server_thread_new_with_proto(cs, proto, _err_handler) * if __exception: # <<<<<<<<<<<<<< * raise __exception * self._server = lo_server_thread_get_server(self._server_thread) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_exception); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 714, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_2)) { /* "pyliblo3/_liblo.pyx":715 * self._server_thread = lo_server_thread_new_with_proto(cs, proto, _err_handler) * if __exception: * raise __exception # <<<<<<<<<<<<<< * self._server = lo_server_thread_get_server(self._server_thread) * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_exception); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 715, __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, 715, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":714 * __exception = None * self._server_thread = lo_server_thread_new_with_proto(cs, proto, _err_handler) * if __exception: # <<<<<<<<<<<<<< * raise __exception * self._server = lo_server_thread_get_server(self._server_thread) */ } /* "pyliblo3/_liblo.pyx":716 * if __exception: * raise __exception * self._server = lo_server_thread_get_server(self._server_thread) # <<<<<<<<<<<<<< * * _ServerBase.__init__(self, reg_methods=reg_methods) */ __pyx_v_self->__pyx_base._server = lo_server_thread_get_server(__pyx_v_self->_server_thread); /* "pyliblo3/_liblo.pyx":718 * self._server = lo_server_thread_get_server(self._server_thread) * * _ServerBase.__init__(self, reg_methods=reg_methods) # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase), __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF((PyObject *)__pyx_v_self); __Pyx_GIVEREF((PyObject *)__pyx_v_self); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(0, 718, __pyx_L1_error); __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_reg_methods, __pyx_v_reg_methods) < 0) __PYX_ERR(0, 718, __pyx_L1_error) __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 718, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "pyliblo3/_liblo.pyx":699 * cdef lo_server_thread _server_thread * * def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): # <<<<<<<<<<<<<< * cdef char *cs * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("pyliblo3._liblo.ServerThread.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_p); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":720 * _ServerBase.__init__(self, reg_methods=reg_methods) * * def __dealloc__(self): # <<<<<<<<<<<<<< * self.free() * */ /* Python wrapper */ static void __pyx_pw_8pyliblo3_6_liblo_12ServerThread_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_8pyliblo3_6_liblo_12ServerThread_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_8pyliblo3_6_liblo_12ServerThread_2__dealloc__(((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_8pyliblo3_6_liblo_12ServerThread_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self) { __Pyx_RefNannyDeclarations 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("__dealloc__", 1); /* "pyliblo3/_liblo.pyx":721 * * def __dealloc__(self): * self.free() # <<<<<<<<<<<<<< * * def free(self): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_free); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":720 * _ServerBase.__init__(self, reg_methods=reg_methods) * * def __dealloc__(self): # <<<<<<<<<<<<<< * self.free() * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyliblo3._liblo.ServerThread.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pyliblo3/_liblo.pyx":723 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_5free(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_12ServerThread_4free, "ServerThread.free(self)\n\n Free the underlying server object and close its port.\n\n !!! note\n\n This method is called automatically when the server is deallocated.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_12ServerThread_5free = {"free", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_5free, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_4free}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_5free(PyObject *__pyx_v_self, #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("free (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("free", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "free", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_12ServerThread_4free(((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_4free(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("free", 1); /* "pyliblo3/_liblo.pyx":731 * This method is called automatically when the server is deallocated. * """ * if self._server_thread: # <<<<<<<<<<<<<< * lo_server_thread_free(self._server_thread) * self._server_thread = NULL */ __pyx_t_1 = (__pyx_v_self->_server_thread != 0); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":732 * """ * if self._server_thread: * lo_server_thread_free(self._server_thread) # <<<<<<<<<<<<<< * self._server_thread = NULL * self._server = NULL */ lo_server_thread_free(__pyx_v_self->_server_thread); /* "pyliblo3/_liblo.pyx":733 * if self._server_thread: * lo_server_thread_free(self._server_thread) * self._server_thread = NULL # <<<<<<<<<<<<<< * self._server = NULL * */ __pyx_v_self->_server_thread = NULL; /* "pyliblo3/_liblo.pyx":734 * lo_server_thread_free(self._server_thread) * self._server_thread = NULL * self._server = NULL # <<<<<<<<<<<<<< * * def start(self): */ __pyx_v_self->__pyx_base._server = NULL; /* "pyliblo3/_liblo.pyx":731 * This method is called automatically when the server is deallocated. * """ * if self._server_thread: # <<<<<<<<<<<<<< * lo_server_thread_free(self._server_thread) * self._server_thread = NULL */ } /* "pyliblo3/_liblo.pyx":723 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":736 * self._server = NULL * * def start(self): # <<<<<<<<<<<<<< * """ * Start the server thread. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_7start(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_12ServerThread_6start, "ServerThread.start(self)\n\n Start the server thread.\n\n liblo will now start to dispatch any messages it receives.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_12ServerThread_7start = {"start", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_7start, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_6start}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_7start(PyObject *__pyx_v_self, #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("start (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("start", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "start", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_12ServerThread_6start(((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_6start(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__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("start", 1); /* "pyliblo3/_liblo.pyx":742 * liblo will now start to dispatch any messages it receives. * """ * self._check() # <<<<<<<<<<<<<< * lo_server_thread_start(self._server_thread) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._check(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":743 * """ * self._check() * lo_server_thread_start(self._server_thread) # <<<<<<<<<<<<<< * * def stop(self): */ lo_server_thread_start(__pyx_v_self->_server_thread); /* "pyliblo3/_liblo.pyx":736 * self._server = NULL * * def start(self): # <<<<<<<<<<<<<< * """ * Start the server thread. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo.ServerThread.start", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":745 * lo_server_thread_start(self._server_thread) * * def stop(self): # <<<<<<<<<<<<<< * """ * Stop the server thread. */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_9stop(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_12ServerThread_8stop, "ServerThread.stop(self)\n\n Stop the server thread.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_12ServerThread_9stop = {"stop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_9stop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_8stop}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_9stop(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stop (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("stop", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "stop", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_12ServerThread_8stop(((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_8stop(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__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("stop", 1); /* "pyliblo3/_liblo.pyx":749 * Stop the server thread. * """ * self._check() # <<<<<<<<<<<<<< * lo_server_thread_stop(self._server_thread) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._check(((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":750 * """ * self._check() * lo_server_thread_stop(self._server_thread) # <<<<<<<<<<<<<< * * */ lo_server_thread_stop(__pyx_v_self->_server_thread); /* "pyliblo3/_liblo.pyx":745 * lo_server_thread_start(self._server_thread) * * def stop(self): # <<<<<<<<<<<<<< * """ * Stop the server thread. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo.ServerThread.stop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_11__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_8pyliblo3_6_liblo_12ServerThread_10__reduce_cython__, "ServerThread.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_12ServerThread_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_10__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_11__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_8pyliblo3_6_liblo_12ServerThread_10__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_12ServerThread_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__server_self__server_thread, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.ServerThread.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_13__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_8pyliblo3_6_liblo_12ServerThread_12__setstate_cython__, "ServerThread.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_12ServerThread_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_12__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_12ServerThread_13__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 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(2, 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(2, 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("pyliblo3._liblo.ServerThread.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_12ServerThread_12__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)__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_8pyliblo3_6_liblo_12ServerThread_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__server_self__server_thread, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.ServerThread.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":761 * Raised when trying to create an invalid `Address` object. * """ * def __init__(self, msg): # <<<<<<<<<<<<<< * self.msg = msg * def __str__(self): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_12AddressError_1__init__(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_8pyliblo3_6_liblo_12AddressError___init__, "AddressError.__init__(self, msg)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_12AddressError_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12AddressError_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12AddressError___init__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_12AddressError_1__init__(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_self = 0; PyObject *__pyx_v_msg = 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("__init__ (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_self,&__pyx_n_s_msg,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 761, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_msg)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 761, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 761, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 761, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_msg = values[1]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 761, __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("pyliblo3._liblo.AddressError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_12AddressError___init__(__pyx_self, __pyx_v_self, __pyx_v_msg); /* 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_8pyliblo3_6_liblo_12AddressError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_msg) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":762 * """ * def __init__(self, msg): * self.msg = msg # <<<<<<<<<<<<<< * def __str__(self): * return "address error: %s" % self.msg */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_msg, __pyx_v_msg) < 0) __PYX_ERR(0, 762, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":761 * Raised when trying to create an invalid `Address` object. * """ * def __init__(self, msg): # <<<<<<<<<<<<<< * self.msg = msg * def __str__(self): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.AddressError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":763 * def __init__(self, msg): * self.msg = msg * def __str__(self): # <<<<<<<<<<<<<< * return "address error: %s" % self.msg * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_12AddressError_3__str__(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_8pyliblo3_6_liblo_12AddressError_2__str__, "AddressError.__str__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_12AddressError_3__str__ = {"__str__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12AddressError_3__str__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12AddressError_2__str__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_12AddressError_3__str__(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_self = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); #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_self,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_self)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 763, __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, "__str__") < 0)) __PYX_ERR(0, 763, __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_self = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 763, __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("pyliblo3._liblo.AddressError.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_12AddressError_2__str__(__pyx_self, __pyx_v_self); /* 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_8pyliblo3_6_liblo_12AddressError_2__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 1); /* "pyliblo3/_liblo.pyx":764 * self.msg = msg * def __str__(self): * return "address error: %s" % self.msg # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_msg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_address_error_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":763 * def __init__(self, msg): * self.msg = msg * def __str__(self): # <<<<<<<<<<<<<< * return "address error: %s" % self.msg * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo.AddressError.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":793 * cdef lo_address _address * * def __init__(self, addr, addr2=None, proto=LO_UDP): # <<<<<<<<<<<<<< * if isinstance(proto, str): * proto = _protostr_to_int(proto) */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_7Address_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_7Address_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_addr = 0; PyObject *__pyx_v_addr2 = 0; PyObject *__pyx_v_proto = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_addr,&__pyx_n_s_addr2,&__pyx_n_s_proto,0}; values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); values[2] = __Pyx_Arg_NewRef_VARARGS(__pyx_k__6); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_addr)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 793, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_addr2); if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 793, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_proto); if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 793, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 793, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_addr = values[0]; __pyx_v_addr2 = values[1]; __pyx_v_proto = values[2]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 793, __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("pyliblo3._liblo.Address.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Address___init__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self), __pyx_v_addr, __pyx_v_addr2, __pyx_v_proto); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_7Address___init__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self, PyObject *__pyx_v_addr, PyObject *__pyx_v_addr2, PyObject *__pyx_v_proto) { PyObject *__pyx_v_s = NULL; PyObject *__pyx_v_s2 = NULL; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; char *__pyx_t_6; char *__pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); __Pyx_INCREF(__pyx_v_proto); /* "pyliblo3/_liblo.pyx":794 * * def __init__(self, addr, addr2=None, proto=LO_UDP): * if isinstance(proto, str): # <<<<<<<<<<<<<< * proto = _protostr_to_int(proto) * */ __pyx_t_1 = PyString_Check(__pyx_v_proto); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":795 * def __init__(self, addr, addr2=None, proto=LO_UDP): * if isinstance(proto, str): * proto = _protostr_to_int(proto) # <<<<<<<<<<<<<< * * if addr2: */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_protostr_to_int); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_proto}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF_SET(__pyx_v_proto, __pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":794 * * def __init__(self, addr, addr2=None, proto=LO_UDP): * if isinstance(proto, str): # <<<<<<<<<<<<<< * proto = _protostr_to_int(proto) * */ } /* "pyliblo3/_liblo.pyx":797 * proto = _protostr_to_int(proto) * * if addr2: # <<<<<<<<<<<<<< * # Address(host, port[, proto]) * s = _encode(addr) */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_addr2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 797, __pyx_L1_error) if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":799 * if addr2: * # Address(host, port[, proto]) * s = _encode(addr) # <<<<<<<<<<<<<< * s2 = _encode(str(addr2)) * self._address = lo_address_new_with_proto(proto, s, s2) */ __pyx_t_2 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_addr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 799, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_s = __pyx_t_2; __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":800 * # Address(host, port[, proto]) * s = _encode(addr) * s2 = _encode(str(addr2)) # <<<<<<<<<<<<<< * self._address = lo_address_new_with_proto(proto, s, s2) * if not self._address: */ __pyx_t_2 = __Pyx_PyObject_Str(__pyx_v_addr2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_s2 = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":801 * s = _encode(addr) * s2 = _encode(str(addr2)) * self._address = lo_address_new_with_proto(proto, s, s2) # <<<<<<<<<<<<<< * if not self._address: * raise AddressError("invalid protocol") */ __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_proto); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 801, __pyx_L1_error) __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 801, __pyx_L1_error) if (unlikely(__pyx_v_s2 == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 801, __pyx_L1_error) } __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_s2); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 801, __pyx_L1_error) __pyx_v_self->_address = lo_address_new_with_proto(__pyx_t_5, __pyx_t_6, __pyx_t_7); /* "pyliblo3/_liblo.pyx":802 * s2 = _encode(str(addr2)) * self._address = lo_address_new_with_proto(proto, s, s2) * if not self._address: # <<<<<<<<<<<<<< * raise AddressError("invalid protocol") * elif isinstance(addr, int) or (isinstance(addr, str) and addr.isdigit()): */ __pyx_t_1 = (!(__pyx_v_self->_address != 0)); if (unlikely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":803 * self._address = lo_address_new_with_proto(proto, s, s2) * if not self._address: * raise AddressError("invalid protocol") # <<<<<<<<<<<<<< * elif isinstance(addr, int) or (isinstance(addr, str) and addr.isdigit()): * # Address(port) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_AddressError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 803, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_s_invalid_protocol}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 803, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 803, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":802 * s2 = _encode(str(addr2)) * self._address = lo_address_new_with_proto(proto, s, s2) * if not self._address: # <<<<<<<<<<<<<< * raise AddressError("invalid protocol") * elif isinstance(addr, int) or (isinstance(addr, str) and addr.isdigit()): */ } /* "pyliblo3/_liblo.pyx":797 * proto = _protostr_to_int(proto) * * if addr2: # <<<<<<<<<<<<<< * # Address(host, port[, proto]) * s = _encode(addr) */ goto __pyx_L4; } /* "pyliblo3/_liblo.pyx":804 * if not self._address: * raise AddressError("invalid protocol") * elif isinstance(addr, int) or (isinstance(addr, str) and addr.isdigit()): # <<<<<<<<<<<<<< * # Address(port) * s = str(addr).encode() */ __pyx_t_8 = PyInt_Check(__pyx_v_addr); if (!__pyx_t_8) { } else { __pyx_t_1 = __pyx_t_8; goto __pyx_L6_bool_binop_done; } __pyx_t_8 = PyString_Check(__pyx_v_addr); if (__pyx_t_8) { } else { __pyx_t_1 = __pyx_t_8; goto __pyx_L6_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_addr, __pyx_n_s_isdigit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 804, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __pyx_t_8; __pyx_L6_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":806 * elif isinstance(addr, int) or (isinstance(addr, str) and addr.isdigit()): * # Address(port) * s = str(addr).encode() # <<<<<<<<<<<<<< * self._address = lo_address_new(NULL, s) * else: */ __pyx_t_2 = __Pyx_PyObject_Str(__pyx_v_addr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 806, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 806, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 806, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_s = __pyx_t_3; __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":807 * # Address(port) * s = str(addr).encode() * self._address = lo_address_new(NULL, s) # <<<<<<<<<<<<<< * else: * # Address(url) */ __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 807, __pyx_L1_error) __pyx_v_self->_address = lo_address_new(NULL, __pyx_t_7); /* "pyliblo3/_liblo.pyx":804 * if not self._address: * raise AddressError("invalid protocol") * elif isinstance(addr, int) or (isinstance(addr, str) and addr.isdigit()): # <<<<<<<<<<<<<< * # Address(port) * s = str(addr).encode() */ goto __pyx_L4; } /* "pyliblo3/_liblo.pyx":810 * else: * # Address(url) * s = _encode(addr) # <<<<<<<<<<<<<< * self._address = lo_address_new_from_url(s) * # lo_address_errno() is of no use if self._addr == NULL */ /*else*/ { __pyx_t_3 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_addr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_s = __pyx_t_3; __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":811 * # Address(url) * s = _encode(addr) * self._address = lo_address_new_from_url(s) # <<<<<<<<<<<<<< * # lo_address_errno() is of no use if self._addr == NULL * if not self._address: */ __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 811, __pyx_L1_error) __pyx_v_self->_address = lo_address_new_from_url(__pyx_t_7); /* "pyliblo3/_liblo.pyx":813 * self._address = lo_address_new_from_url(s) * # lo_address_errno() is of no use if self._addr == NULL * if not self._address: # <<<<<<<<<<<<<< * raise AddressError("invalid URL '%s'" % str(addr)) * */ __pyx_t_1 = (!(__pyx_v_self->_address != 0)); if (unlikely(__pyx_t_1)) { /* "pyliblo3/_liblo.pyx":814 * # lo_address_errno() is of no use if self._addr == NULL * if not self._address: * raise AddressError("invalid URL '%s'" % str(addr)) # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_AddressError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_Str(__pyx_v_addr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = __Pyx_PyString_FormatSafe(__pyx_kp_s_invalid_URL_s, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_9}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 814, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":813 * self._address = lo_address_new_from_url(s) * # lo_address_errno() is of no use if self._addr == NULL * if not self._address: # <<<<<<<<<<<<<< * raise AddressError("invalid URL '%s'" % str(addr)) * */ } } __pyx_L4:; /* "pyliblo3/_liblo.pyx":793 * cdef lo_address _address * * def __init__(self, addr, addr2=None, proto=LO_UDP): # <<<<<<<<<<<<<< * if isinstance(proto, str): * proto = _protostr_to_int(proto) */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("pyliblo3._liblo.Address.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_s); __Pyx_XDECREF(__pyx_v_s2); __Pyx_XDECREF(__pyx_v_proto); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":816 * raise AddressError("invalid URL '%s'" % str(addr)) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_address_free(self._address) * */ /* Python wrapper */ static void __pyx_pw_8pyliblo3_6_liblo_7Address_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_8pyliblo3_6_liblo_7Address_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_8pyliblo3_6_liblo_7Address_2__dealloc__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_8pyliblo3_6_liblo_7Address_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { /* "pyliblo3/_liblo.pyx":817 * * def __dealloc__(self): * lo_address_free(self._address) # <<<<<<<<<<<<<< * * def get_url(self): */ lo_address_free(__pyx_v_self->_address); /* "pyliblo3/_liblo.pyx":816 * raise AddressError("invalid URL '%s'" % str(addr)) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_address_free(self._address) * */ /* function exit code */ } /* "pyliblo3/_liblo.pyx":819 * lo_address_free(self._address) * * def get_url(self): # <<<<<<<<<<<<<< * """This Address as a liblo URL""" * cdef char *tmp = lo_address_get_url(self._address) */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_5get_url(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_7Address_4get_url, "Address.get_url(self)\nThis Address as a liblo URL"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Address_5get_url = {"get_url", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_5get_url, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_4get_url}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_5get_url(PyObject *__pyx_v_self, #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_url (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_url", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_url", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Address_4get_url(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_4get_url(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { char *__pyx_v_tmp; PyObject *__pyx_v_r = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_url", 1); /* "pyliblo3/_liblo.pyx":821 * def get_url(self): * """This Address as a liblo URL""" * cdef char *tmp = lo_address_get_url(self._address) # <<<<<<<<<<<<<< * cdef object r = tmp * free(tmp) */ __pyx_v_tmp = lo_address_get_url(__pyx_v_self->_address); /* "pyliblo3/_liblo.pyx":822 * """This Address as a liblo URL""" * cdef char *tmp = lo_address_get_url(self._address) * cdef object r = tmp # <<<<<<<<<<<<<< * free(tmp) * return _decode(r) */ __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_tmp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_r = __pyx_t_1; __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":823 * cdef char *tmp = lo_address_get_url(self._address) * cdef object r = tmp * free(tmp) # <<<<<<<<<<<<<< * return _decode(r) * */ free(__pyx_v_tmp); /* "pyliblo3/_liblo.pyx":824 * cdef object r = tmp * free(tmp) * return _decode(r) # <<<<<<<<<<<<<< * * def get_hostname(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_v_r); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":819 * lo_address_free(self._address) * * def get_url(self): # <<<<<<<<<<<<<< * """This Address as a liblo URL""" * cdef char *tmp = lo_address_get_url(self._address) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo.Address.get_url", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_r); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":826 * return _decode(r) * * def get_hostname(self): # <<<<<<<<<<<<<< * """The hostname of this Address""" * return _decode(lo_address_get_hostname(self._address)) */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_7get_hostname(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_7Address_6get_hostname, "Address.get_hostname(self)\nThe hostname of this Address"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Address_7get_hostname = {"get_hostname", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_7get_hostname, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_6get_hostname}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_7get_hostname(PyObject *__pyx_v_self, #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_hostname (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_hostname", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_hostname", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Address_6get_hostname(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_6get_hostname(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_hostname", 1); /* "pyliblo3/_liblo.pyx":828 * def get_hostname(self): * """The hostname of this Address""" * return _decode(lo_address_get_hostname(self._address)) # <<<<<<<<<<<<<< * * def get_port(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBytes_FromString(lo_address_get_hostname(__pyx_v_self->_address)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":826 * return _decode(r) * * def get_hostname(self): # <<<<<<<<<<<<<< * """The hostname of this Address""" * return _decode(lo_address_get_hostname(self._address)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo.Address.get_hostname", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":830 * return _decode(lo_address_get_hostname(self._address)) * * def get_port(self): # <<<<<<<<<<<<<< * """The port number of this Address""" * cdef bytes s = lo_address_get_port(self._address) */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_9get_port(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_7Address_8get_port, "Address.get_port(self)\nThe port number of this Address"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Address_9get_port = {"get_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_9get_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_8get_port}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_9get_port(PyObject *__pyx_v_self, #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_port (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_port", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_port", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Address_8get_port(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_8get_port(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_v_s = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_port", 1); /* "pyliblo3/_liblo.pyx":832 * def get_port(self): * """The port number of this Address""" * cdef bytes s = lo_address_get_port(self._address) # <<<<<<<<<<<<<< * if s.isdigit(): * return int(s) */ __pyx_t_1 = __Pyx_PyBytes_FromString(lo_address_get_port(__pyx_v_self->_address)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 832, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_s = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":833 * """The port number of this Address""" * cdef bytes s = lo_address_get_port(self._address) * if s.isdigit(): # <<<<<<<<<<<<<< * return int(s) * else: */ __pyx_t_1 = __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyBytes_Type_isdigit, __pyx_v_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 833, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 833, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":834 * cdef bytes s = lo_address_get_port(self._address) * if s.isdigit(): * return int(s) # <<<<<<<<<<<<<< * else: * return _decode(s) */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyNumber_Int(__pyx_v_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":833 * """The port number of this Address""" * cdef bytes s = lo_address_get_port(self._address) * if s.isdigit(): # <<<<<<<<<<<<<< * return int(s) * else: */ } /* "pyliblo3/_liblo.pyx":836 * return int(s) * else: * return _decode(s) # <<<<<<<<<<<<<< * * def get_protocol(self): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_v_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; } /* "pyliblo3/_liblo.pyx":830 * return _decode(lo_address_get_hostname(self._address)) * * def get_port(self): # <<<<<<<<<<<<<< * """The port number of this Address""" * cdef bytes s = lo_address_get_port(self._address) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo.Address.get_port", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_s); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":838 * return _decode(s) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * The protocol used as an int */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_11get_protocol(PyObject *__pyx_v_self, #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_8pyliblo3_6_liblo_7Address_10get_protocol, "Address.get_protocol(self)\n\n The protocol used as an int\n\n Example\n -------\n\n ```python\n from pyliblo3 import *\n address = Address('127.0.0.0', 9876)\n assert address.get_protocol() == LO_UDP\n ```\n\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Address_11get_protocol = {"get_protocol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_11get_protocol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_10get_protocol}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_11get_protocol(PyObject *__pyx_v_self, #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_protocol (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_protocol", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_protocol", 0))) return NULL; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Address_10get_protocol(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_10get_protocol(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_protocol", 1); /* "pyliblo3/_liblo.pyx":852 * * """ * return lo_address_get_protocol(self._address) # <<<<<<<<<<<<<< * * property url: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(lo_address_get_protocol(__pyx_v_self->_address)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyliblo3/_liblo.pyx":838 * return _decode(s) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * The protocol used as an int */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyliblo3._liblo.Address.get_protocol", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":858 * The address's URL. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_url() * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_3url_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_3url_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_8pyliblo3_6_liblo_7Address_3url___get__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_3url___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "pyliblo3/_liblo.pyx":859 * """ * def __get__(self): * return self.get_url() # <<<<<<<<<<<<<< * * property hostname: */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_url); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 859, __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; /* "pyliblo3/_liblo.pyx":858 * The address's URL. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_url() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo.Address.url.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":865 * The address's hostname. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_hostname() * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_8hostname_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_8hostname_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_8pyliblo3_6_liblo_7Address_8hostname___get__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_8hostname___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "pyliblo3/_liblo.pyx":866 * """ * def __get__(self): * return self.get_hostname() # <<<<<<<<<<<<<< * * property port: */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_hostname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 866, __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; /* "pyliblo3/_liblo.pyx":865 * The address's hostname. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_hostname() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo.Address.hostname.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":872 * The address's port number. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_port() * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_4port_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_4port_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_8pyliblo3_6_liblo_7Address_4port___get__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_4port___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "pyliblo3/_liblo.pyx":873 * """ * def __get__(self): * return self.get_port() # <<<<<<<<<<<<<< * * property protocol: */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_port); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 873, __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; /* "pyliblo3/_liblo.pyx":872 * The address's port number. * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_port() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo.Address.port.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":880 * :const:`TCP`, or :const:`UNIX`). * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_protocol() * */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_8protocol_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_8protocol_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_8pyliblo3_6_liblo_7Address_8protocol___get__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_8protocol___get__(struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "pyliblo3/_liblo.pyx":881 * """ * def __get__(self): * return self.get_protocol() # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_protocol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __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; } } #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, 881, __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; /* "pyliblo3/_liblo.pyx":880 * :const:`TCP`, or :const:`UNIX`). * """ * def __get__(self): # <<<<<<<<<<<<<< * return self.get_protocol() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo.Address.protocol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_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_8pyliblo3_6_liblo_7Address_12__reduce_cython__, "Address.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Address_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_12__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_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_8pyliblo3_6_liblo_7Address_12__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self._address cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._address cannot be converted to a Python object for pickling" */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__address_cannot_be_converte, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Address.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_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_8pyliblo3_6_liblo_7Address_14__setstate_cython__, "Address.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Address_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_14__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Address_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); #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(2, 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(2, 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(2, 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("pyliblo3._liblo.Address.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Address_14__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Address *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Address_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Address *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._address cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__address_cannot_be_converte, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Address.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":891 * cdef lo_blob _blob * * def __init__(self, arr): # <<<<<<<<<<<<<< * # arr can by any sequence type * cdef unsigned char *p */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_5_Blob_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_5_Blob_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_arr = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arr,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_arr)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 891, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 891, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_arr = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 891, __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("pyliblo3._liblo._Blob.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_5_Blob___init__(((struct __pyx_obj_8pyliblo3_6_liblo__Blob *)__pyx_v_self), __pyx_v_arr); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_5_Blob___init__(struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self, PyObject *__pyx_v_arr) { unsigned char *__pyx_v_p; uint32_t __pyx_v_size; uint32_t __pyx_v_i; int __pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; uint32_t __pyx_t_5; long __pyx_t_6; unsigned char __pyx_t_7; int __pyx_t_8; int __pyx_t_9; char const *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":895 * cdef unsigned char *p * cdef uint32_t size, i * size = len(arr) # <<<<<<<<<<<<<< * if size < 1: * raise ValueError("blob is empty") */ __pyx_t_1 = PyObject_Length(__pyx_v_arr); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 895, __pyx_L1_error) __pyx_v_size = __pyx_t_1; /* "pyliblo3/_liblo.pyx":896 * cdef uint32_t size, i * size = len(arr) * if size < 1: # <<<<<<<<<<<<<< * raise ValueError("blob is empty") * # copy each element of arr to a C array */ __pyx_t_2 = (__pyx_v_size < 1); if (unlikely(__pyx_t_2)) { /* "pyliblo3/_liblo.pyx":897 * size = len(arr) * if size < 1: * raise ValueError("blob is empty") # <<<<<<<<<<<<<< * # copy each element of arr to a C array * p = malloc(size) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 897, __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, 897, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":896 * cdef uint32_t size, i * size = len(arr) * if size < 1: # <<<<<<<<<<<<<< * raise ValueError("blob is empty") * # copy each element of arr to a C array */ } /* "pyliblo3/_liblo.pyx":899 * raise ValueError("blob is empty") * # copy each element of arr to a C array * p = malloc(size) # <<<<<<<<<<<<<< * try: * if isinstance(arr[0], (str, unicode)): */ __pyx_v_p = ((unsigned char *)malloc(__pyx_v_size)); /* "pyliblo3/_liblo.pyx":900 * # copy each element of arr to a C array * p = malloc(size) * try: # <<<<<<<<<<<<<< * if isinstance(arr[0], (str, unicode)): * # use ord() if arr is a string (but not bytes) */ /*try:*/ { /* "pyliblo3/_liblo.pyx":901 * p = malloc(size) * try: * if isinstance(arr[0], (str, unicode)): # <<<<<<<<<<<<<< * # use ord() if arr is a string (but not bytes) * for i from 0 <= i < size: */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 901, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyString_Check(__pyx_t_3); if (!__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L8_bool_binop_done; } __pyx_t_4 = PyUnicode_Check(__pyx_t_3); __pyx_t_2 = __pyx_t_4; __pyx_L8_bool_binop_done:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":903 * if isinstance(arr[0], (str, unicode)): * # use ord() if arr is a string (but not bytes) * for i from 0 <= i < size: # <<<<<<<<<<<<<< * p[i] = ord(arr[i]) * else: */ __pyx_t_5 = __pyx_v_size; for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_5; __pyx_v_i++) { /* "pyliblo3/_liblo.pyx":904 * # use ord() if arr is a string (but not bytes) * for i from 0 <= i < size: * p[i] = ord(arr[i]) # <<<<<<<<<<<<<< * else: * for i from 0 <= i < size: */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arr, __pyx_v_i, uint32_t, 0, __Pyx_PyInt_From_uint32_t, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 904, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyObject_Ord(__pyx_t_3); if (unlikely(__pyx_t_6 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 904, __pyx_L5_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; (__pyx_v_p[__pyx_v_i]) = __pyx_t_6; } /* "pyliblo3/_liblo.pyx":901 * p = malloc(size) * try: * if isinstance(arr[0], (str, unicode)): # <<<<<<<<<<<<<< * # use ord() if arr is a string (but not bytes) * for i from 0 <= i < size: */ goto __pyx_L7; } /* "pyliblo3/_liblo.pyx":906 * p[i] = ord(arr[i]) * else: * for i from 0 <= i < size: # <<<<<<<<<<<<<< * p[i] = arr[i] * # build blob */ /*else*/ { __pyx_t_5 = __pyx_v_size; for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_5; __pyx_v_i++) { /* "pyliblo3/_liblo.pyx":907 * else: * for i from 0 <= i < size: * p[i] = arr[i] # <<<<<<<<<<<<<< * # build blob * self._blob = lo_blob_new(size, p) */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arr, __pyx_v_i, uint32_t, 0, __Pyx_PyInt_From_uint32_t, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 907, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyInt_As_unsigned_char(__pyx_t_3); if (unlikely((__pyx_t_7 == (unsigned char)-1) && PyErr_Occurred())) __PYX_ERR(0, 907, __pyx_L5_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; (__pyx_v_p[__pyx_v_i]) = __pyx_t_7; } } __pyx_L7:; /* "pyliblo3/_liblo.pyx":909 * p[i] = arr[i] * # build blob * self._blob = lo_blob_new(size, p) # <<<<<<<<<<<<<< * finally: * free(p) */ __pyx_v_self->_blob = lo_blob_new(__pyx_v_size, __pyx_v_p); } /* "pyliblo3/_liblo.pyx":911 * self._blob = lo_blob_new(size, p) * finally: * free(p) # <<<<<<<<<<<<<< * * def __dealloc__(self): */ /*finally:*/ { /*normal exit:*/{ free(__pyx_v_p); goto __pyx_L6; } __pyx_L5_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_8 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename; { free(__pyx_v_p); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10; goto __pyx_L1_error; } __pyx_L6:; } /* "pyliblo3/_liblo.pyx":891 * cdef lo_blob _blob * * def __init__(self, arr): # <<<<<<<<<<<<<< * # arr can by any sequence type * cdef unsigned char *p */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo._Blob.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":913 * free(p) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_blob_free(self._blob) * */ /* Python wrapper */ static void __pyx_pw_8pyliblo3_6_liblo_5_Blob_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_8pyliblo3_6_liblo_5_Blob_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_8pyliblo3_6_liblo_5_Blob_2__dealloc__(((struct __pyx_obj_8pyliblo3_6_liblo__Blob *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_8pyliblo3_6_liblo_5_Blob_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self) { /* "pyliblo3/_liblo.pyx":914 * * def __dealloc__(self): * lo_blob_free(self._blob) # <<<<<<<<<<<<<< * * */ lo_blob_free(__pyx_v_self->_blob); /* "pyliblo3/_liblo.pyx":913 * free(p) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_blob_free(self._blob) * */ /* function exit code */ } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_5_Blob_5__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_8pyliblo3_6_liblo_5_Blob_4__reduce_cython__, "_Blob.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_5_Blob_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_5_Blob_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_5_Blob_4__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_5_Blob_5__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_8pyliblo3_6_liblo_5_Blob_4__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo__Blob *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_5_Blob_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self._blob cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._blob cannot be converted to a Python object for pickling" */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__blob_cannot_be_converted_t, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo._Blob.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_5_Blob_7__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_8pyliblo3_6_liblo_5_Blob_6__setstate_cython__, "_Blob.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_5_Blob_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_5_Blob_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_5_Blob_6__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_5_Blob_7__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 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(2, 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(2, 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("pyliblo3._liblo._Blob.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_5_Blob_6__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo__Blob *)__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_8pyliblo3_6_liblo_5_Blob_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._blob cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__blob_cannot_be_converted_t, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo._Blob.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":929 * cdef list _keep_refs * * def __init__(self, path, *args): # <<<<<<<<<<<<<< * self._keep_refs = [] * # encode path to bytestring if necessary */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_7Message_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_7Message_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_args = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_v_args = __Pyx_ArgsSlice_VARARGS(__pyx_args, 1, __pyx_nargs); if (unlikely(!__pyx_v_args)) { __Pyx_RefNannyFinishContext(); return -1; } __Pyx_GOTREF(__pyx_v_args); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { default: case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 929, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, used_pos_args, "__init__") < 0)) __PYX_ERR(0, 929, __pyx_L3_error) } } else if (unlikely(__pyx_nargs < 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_path = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 929, __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_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_AddTraceback("pyliblo3._liblo.Message.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Message___init__(((struct __pyx_obj_8pyliblo3_6_liblo_Message *)__pyx_v_self), __pyx_v_path, __pyx_v_args); /* function exit code */ __Pyx_DECREF(__pyx_v_args); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_7Message___init__(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_path, PyObject *__pyx_v_args) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 1); /* "pyliblo3/_liblo.pyx":930 * * def __init__(self, path, *args): * self._keep_refs = [] # <<<<<<<<<<<<<< * # encode path to bytestring if necessary * self._path = _encode(path) */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_keep_refs); __Pyx_DECREF(__pyx_v_self->_keep_refs); __pyx_v_self->_keep_refs = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":932 * self._keep_refs = [] * # encode path to bytestring if necessary * self._path = _encode(path) # <<<<<<<<<<<<<< * self._message = lo_message_new() * */ __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 932, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->_path); __Pyx_DECREF(__pyx_v_self->_path); __pyx_v_self->_path = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":933 * # encode path to bytestring if necessary * self._path = _encode(path) * self._message = lo_message_new() # <<<<<<<<<<<<<< * * self.add(*args) */ __pyx_v_self->_message = lo_message_new(); /* "pyliblo3/_liblo.pyx":935 * self._message = lo_message_new() * * self.add(*args) # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 935, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 935, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":929 * cdef list _keep_refs * * def __init__(self, path, *args): # <<<<<<<<<<<<<< * self._keep_refs = [] * # encode path to bytestring if necessary */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo.Message.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":937 * self.add(*args) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_message_free(self._message) * */ /* Python wrapper */ static void __pyx_pw_8pyliblo3_6_liblo_7Message_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_8pyliblo3_6_liblo_7Message_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_8pyliblo3_6_liblo_7Message_2__dealloc__(((struct __pyx_obj_8pyliblo3_6_liblo_Message *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_8pyliblo3_6_liblo_7Message_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self) { /* "pyliblo3/_liblo.pyx":938 * * def __dealloc__(self): * lo_message_free(self._message) # <<<<<<<<<<<<<< * * def add(self, *args): */ lo_message_free(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":937 * self.add(*args) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_message_free(self._message) * */ /* function exit code */ } /* "pyliblo3/_liblo.pyx":940 * lo_message_free(self._message) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Append the given arguments to this message */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Message_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ PyDoc_STRVAR(__pyx_doc_8pyliblo3_6_liblo_7Message_4add, "Message.add(self, *args)\n\n Append the given arguments to this message\n\n Arguments can be single values or `(typetag, data)` tuples to specify\n the actual type. This might be needed for numbers, to specify if a float\n needs to be encoded as a 32-bit (typetag = 'f') or 64-bit float (typetag = 'd').\n By default, float numbers are interpreted as 32-bit floats.\n\n Args:\n args: each argument can be a single value or a tuple `(typetag: str, data: Any)`\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Message_5add = {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Message_5add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Message_4add}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Message_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_args = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "add", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_args = __pyx_args; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Message_4add(((struct __pyx_obj_8pyliblo3_6_liblo_Message *)__pyx_v_self), __pyx_v_args); /* function exit code */ __Pyx_DECREF(__pyx_v_args); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Message_4add(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_args) { PyObject *__pyx_v_arg = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; Py_ssize_t __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add", 1); /* "pyliblo3/_liblo.pyx":952 * args: each argument can be a single value or a tuple `(typetag: str, data: Any)` * """ * for arg in args: # <<<<<<<<<<<<<< * if (isinstance(arg, tuple) and len(arg) <= 2 and * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): */ __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 952, __pyx_L1_error) #endif if (__pyx_t_2 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(0, 952, __pyx_L1_error) #else __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 952, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":953 * """ * for arg in args: * if (isinstance(arg, tuple) and len(arg) <= 2 and # <<<<<<<<<<<<<< * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): * # type explicitly specified */ __pyx_t_5 = PyTuple_Check(__pyx_v_arg); if (__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L6_bool_binop_done; } __pyx_t_6 = PyObject_Length(__pyx_v_arg); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 953, __pyx_L1_error) __pyx_t_5 = (__pyx_t_6 <= 2); if (__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L6_bool_binop_done; } /* "pyliblo3/_liblo.pyx":954 * for arg in args: * if (isinstance(arg, tuple) and len(arg) <= 2 and * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): # <<<<<<<<<<<<<< * # type explicitly specified * if len(arg) == 2: */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arg, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 954, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = PyBytes_Check(__pyx_t_3); if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; goto __pyx_L10_bool_binop_done; } __pyx_t_7 = PyUnicode_Check(__pyx_t_3); __pyx_t_5 = __pyx_t_7; __pyx_L10_bool_binop_done:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_5) { } else { __pyx_t_4 = __pyx_t_5; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arg, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 954, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 954, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = (__pyx_t_6 == 1); __pyx_t_4 = __pyx_t_5; __pyx_L6_bool_binop_done:; /* "pyliblo3/_liblo.pyx":953 * """ * for arg in args: * if (isinstance(arg, tuple) and len(arg) <= 2 and # <<<<<<<<<<<<<< * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): * # type explicitly specified */ if (__pyx_t_4) { /* "pyliblo3/_liblo.pyx":956 * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): * # type explicitly specified * if len(arg) == 2: # <<<<<<<<<<<<<< * self._add(arg[0], arg[1]) * else: */ __pyx_t_6 = PyObject_Length(__pyx_v_arg); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 956, __pyx_L1_error) __pyx_t_4 = (__pyx_t_6 == 2); if (__pyx_t_4) { /* "pyliblo3/_liblo.pyx":957 * # type explicitly specified * if len(arg) == 2: * self._add(arg[0], arg[1]) # <<<<<<<<<<<<<< * else: * self._add(arg[0], None) */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arg, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 957, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_arg, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 957, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message *)__pyx_v_self->__pyx_vtab)->_add(__pyx_v_self, __pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 957, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "pyliblo3/_liblo.pyx":956 * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): * # type explicitly specified * if len(arg) == 2: # <<<<<<<<<<<<<< * self._add(arg[0], arg[1]) * else: */ goto __pyx_L12; } /* "pyliblo3/_liblo.pyx":959 * self._add(arg[0], arg[1]) * else: * self._add(arg[0], None) # <<<<<<<<<<<<<< * else: * # detect type automatically */ /*else*/ { __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_arg, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message *)__pyx_v_self->__pyx_vtab)->_add(__pyx_v_self, __pyx_t_9, Py_None); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __pyx_L12:; /* "pyliblo3/_liblo.pyx":953 * """ * for arg in args: * if (isinstance(arg, tuple) and len(arg) <= 2 and # <<<<<<<<<<<<<< * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): * # type explicitly specified */ goto __pyx_L5; } /* "pyliblo3/_liblo.pyx":962 * else: * # detect type automatically * self._add_auto(arg) # <<<<<<<<<<<<<< * * cdef _add(self, type, value): */ /*else*/ { __pyx_t_8 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message *)__pyx_v_self->__pyx_vtab)->_add_auto(__pyx_v_self, __pyx_v_arg); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 962, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __pyx_L5:; /* "pyliblo3/_liblo.pyx":952 * args: each argument can be a single value or a tuple `(typetag: str, data: Any)` * """ * for arg in args: # <<<<<<<<<<<<<< * if (isinstance(arg, tuple) and len(arg) <= 2 and * isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":940 * lo_message_free(self._message) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Append the given arguments to this message */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("pyliblo3._liblo.Message.add", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_arg); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":964 * self._add_auto(arg) * * cdef _add(self, type, value): # <<<<<<<<<<<<<< * cdef uint8_t midi[4] * */ static PyObject *__pyx_f_8pyliblo3_6_liblo_7Message__add(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_type, PyObject *__pyx_v_value) { uint8_t __pyx_v_midi[4]; char __pyx_v_t; PyObject *__pyx_v_s = NULL; long __pyx_v_n; struct __pyx_obj_8pyliblo3_6_liblo__Blob *__pyx_v_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; long __pyx_t_3; int32_t __pyx_t_4; int64_t __pyx_t_5; double __pyx_t_6; char *__pyx_t_7; uint8_t __pyx_t_8; lo_timetag __pyx_t_9; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_add", 1); /* "pyliblo3/_liblo.pyx":968 * * # accept both bytes and unicode as type specifier * cdef char t = ord(_decode(type)[0]) # <<<<<<<<<<<<<< * * if t == 'i': */ __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo__decode(__pyx_v_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 968, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 968, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_Ord(__pyx_t_2); if (unlikely(__pyx_t_3 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 968, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_t = __pyx_t_3; /* "pyliblo3/_liblo.pyx":970 * cdef char t = ord(_decode(type)[0]) * * if t == 'i': # <<<<<<<<<<<<<< * lo_message_add_int32(self._message, int(value)) * elif t == 'h': */ switch (__pyx_v_t) { case 'i': /* "pyliblo3/_liblo.pyx":971 * * if t == 'i': * lo_message_add_int32(self._message, int(value)) # <<<<<<<<<<<<<< * elif t == 'h': * lo_message_add_int64(self._message, long(value)) */ __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyInt_As_int32_t(__pyx_t_2); if (unlikely((__pyx_t_4 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 971, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; lo_message_add_int32(__pyx_v_self->_message, __pyx_t_4); /* "pyliblo3/_liblo.pyx":970 * cdef char t = ord(_decode(type)[0]) * * if t == 'i': # <<<<<<<<<<<<<< * lo_message_add_int32(self._message, int(value)) * elif t == 'h': */ break; case 'h': /* "pyliblo3/_liblo.pyx":973 * lo_message_add_int32(self._message, int(value)) * elif t == 'h': * lo_message_add_int64(self._message, long(value)) # <<<<<<<<<<<<<< * elif t == 'f': * lo_message_add_float(self._message, float(value)) */ __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyLong_Type)), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 973, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; lo_message_add_int64(__pyx_v_self->_message, __pyx_t_5); /* "pyliblo3/_liblo.pyx":972 * if t == 'i': * lo_message_add_int32(self._message, int(value)) * elif t == 'h': # <<<<<<<<<<<<<< * lo_message_add_int64(self._message, long(value)) * elif t == 'f': */ break; case 'f': /* "pyliblo3/_liblo.pyx":975 * lo_message_add_int64(self._message, long(value)) * elif t == 'f': * lo_message_add_float(self._message, float(value)) # <<<<<<<<<<<<<< * elif t == 'd': * lo_message_add_double(self._message, float(value)) */ __pyx_t_6 = __Pyx_PyObject_AsDouble(__pyx_v_value); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 975, __pyx_L1_error) lo_message_add_float(__pyx_v_self->_message, __pyx_t_6); /* "pyliblo3/_liblo.pyx":974 * elif t == 'h': * lo_message_add_int64(self._message, long(value)) * elif t == 'f': # <<<<<<<<<<<<<< * lo_message_add_float(self._message, float(value)) * elif t == 'd': */ break; case 'd': /* "pyliblo3/_liblo.pyx":977 * lo_message_add_float(self._message, float(value)) * elif t == 'd': * lo_message_add_double(self._message, float(value)) # <<<<<<<<<<<<<< * elif t == 'c': * lo_message_add_char(self._message, ord(value)) */ __pyx_t_6 = __Pyx_PyObject_AsDouble(__pyx_v_value); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 977, __pyx_L1_error) lo_message_add_double(__pyx_v_self->_message, __pyx_t_6); /* "pyliblo3/_liblo.pyx":976 * elif t == 'f': * lo_message_add_float(self._message, float(value)) * elif t == 'd': # <<<<<<<<<<<<<< * lo_message_add_double(self._message, float(value)) * elif t == 'c': */ break; case 'c': /* "pyliblo3/_liblo.pyx":979 * lo_message_add_double(self._message, float(value)) * elif t == 'c': * lo_message_add_char(self._message, ord(value)) # <<<<<<<<<<<<<< * elif t == 's': * s = _encode(value) */ __pyx_t_3 = __Pyx_PyObject_Ord(__pyx_v_value); if (unlikely(__pyx_t_3 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 979, __pyx_L1_error) lo_message_add_char(__pyx_v_self->_message, __pyx_t_3); /* "pyliblo3/_liblo.pyx":978 * elif t == 'd': * lo_message_add_double(self._message, float(value)) * elif t == 'c': # <<<<<<<<<<<<<< * lo_message_add_char(self._message, ord(value)) * elif t == 's': */ break; case 's': /* "pyliblo3/_liblo.pyx":981 * lo_message_add_char(self._message, ord(value)) * elif t == 's': * s = _encode(value) # <<<<<<<<<<<<<< * lo_message_add_string(self._message, s) * elif t == 'S': */ __pyx_t_2 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 981, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_s = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":982 * elif t == 's': * s = _encode(value) * lo_message_add_string(self._message, s) # <<<<<<<<<<<<<< * elif t == 'S': * s = _encode(value) */ if (unlikely(__pyx_v_s == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 982, __pyx_L1_error) } __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 982, __pyx_L1_error) lo_message_add_string(__pyx_v_self->_message, __pyx_t_7); /* "pyliblo3/_liblo.pyx":980 * elif t == 'c': * lo_message_add_char(self._message, ord(value)) * elif t == 's': # <<<<<<<<<<<<<< * s = _encode(value) * lo_message_add_string(self._message, s) */ break; case 'S': /* "pyliblo3/_liblo.pyx":984 * lo_message_add_string(self._message, s) * elif t == 'S': * s = _encode(value) # <<<<<<<<<<<<<< * lo_message_add_symbol(self._message, s) * elif t == 'T': */ __pyx_t_2 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 984, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_s = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":985 * elif t == 'S': * s = _encode(value) * lo_message_add_symbol(self._message, s) # <<<<<<<<<<<<<< * elif t == 'T': * lo_message_add_true(self._message) */ if (unlikely(__pyx_v_s == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 985, __pyx_L1_error) } __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 985, __pyx_L1_error) lo_message_add_symbol(__pyx_v_self->_message, __pyx_t_7); /* "pyliblo3/_liblo.pyx":983 * s = _encode(value) * lo_message_add_string(self._message, s) * elif t == 'S': # <<<<<<<<<<<<<< * s = _encode(value) * lo_message_add_symbol(self._message, s) */ break; case 'T': /* "pyliblo3/_liblo.pyx":987 * lo_message_add_symbol(self._message, s) * elif t == 'T': * lo_message_add_true(self._message) # <<<<<<<<<<<<<< * elif t == 'F': * lo_message_add_false(self._message) */ lo_message_add_true(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":986 * s = _encode(value) * lo_message_add_symbol(self._message, s) * elif t == 'T': # <<<<<<<<<<<<<< * lo_message_add_true(self._message) * elif t == 'F': */ break; case 'F': /* "pyliblo3/_liblo.pyx":989 * lo_message_add_true(self._message) * elif t == 'F': * lo_message_add_false(self._message) # <<<<<<<<<<<<<< * elif t == 'N': * lo_message_add_nil(self._message) */ lo_message_add_false(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":988 * elif t == 'T': * lo_message_add_true(self._message) * elif t == 'F': # <<<<<<<<<<<<<< * lo_message_add_false(self._message) * elif t == 'N': */ break; case 'N': /* "pyliblo3/_liblo.pyx":991 * lo_message_add_false(self._message) * elif t == 'N': * lo_message_add_nil(self._message) # <<<<<<<<<<<<<< * elif t == 'I': * lo_message_add_infinitum(self._message) */ lo_message_add_nil(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":990 * elif t == 'F': * lo_message_add_false(self._message) * elif t == 'N': # <<<<<<<<<<<<<< * lo_message_add_nil(self._message) * elif t == 'I': */ break; case 'I': /* "pyliblo3/_liblo.pyx":993 * lo_message_add_nil(self._message) * elif t == 'I': * lo_message_add_infinitum(self._message) # <<<<<<<<<<<<<< * elif t == 'm': * for n from 0 <= n < 4: */ lo_message_add_infinitum(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":992 * elif t == 'N': * lo_message_add_nil(self._message) * elif t == 'I': # <<<<<<<<<<<<<< * lo_message_add_infinitum(self._message) * elif t == 'm': */ break; case 'm': /* "pyliblo3/_liblo.pyx":995 * lo_message_add_infinitum(self._message) * elif t == 'm': * for n from 0 <= n < 4: # <<<<<<<<<<<<<< * midi[n] = value[n] * lo_message_add_midi(self._message, midi) */ for (__pyx_v_n = 0; __pyx_v_n < 4; __pyx_v_n++) { /* "pyliblo3/_liblo.pyx":996 * elif t == 'm': * for n from 0 <= n < 4: * midi[n] = value[n] # <<<<<<<<<<<<<< * lo_message_add_midi(self._message, midi) * elif t == 't': */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_value, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 996, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = __Pyx_PyInt_As_uint8_t(__pyx_t_2); if (unlikely((__pyx_t_8 == ((uint8_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; (__pyx_v_midi[__pyx_v_n]) = __pyx_t_8; } /* "pyliblo3/_liblo.pyx":997 * for n from 0 <= n < 4: * midi[n] = value[n] * lo_message_add_midi(self._message, midi) # <<<<<<<<<<<<<< * elif t == 't': * lo_message_add_timetag(self._message, _double_to_timetag(value)) */ lo_message_add_midi(__pyx_v_self->_message, __pyx_v_midi); /* "pyliblo3/_liblo.pyx":994 * elif t == 'I': * lo_message_add_infinitum(self._message) * elif t == 'm': # <<<<<<<<<<<<<< * for n from 0 <= n < 4: * midi[n] = value[n] */ break; case 't': /* "pyliblo3/_liblo.pyx":999 * lo_message_add_midi(self._message, midi) * elif t == 't': * lo_message_add_timetag(self._message, _double_to_timetag(value)) # <<<<<<<<<<<<<< * elif t == 'b': * b = _Blob(value) */ __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 999, __pyx_L1_error) __pyx_t_9 = __pyx_f_8pyliblo3_6_liblo__double_to_timetag(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 999, __pyx_L1_error) lo_message_add_timetag(__pyx_v_self->_message, __pyx_t_9); /* "pyliblo3/_liblo.pyx":998 * midi[n] = value[n] * lo_message_add_midi(self._message, midi) * elif t == 't': # <<<<<<<<<<<<<< * lo_message_add_timetag(self._message, _double_to_timetag(value)) * elif t == 'b': */ break; case 'b': /* "pyliblo3/_liblo.pyx":1001 * lo_message_add_timetag(self._message, _double_to_timetag(value)) * elif t == 'b': * b = _Blob(value) # <<<<<<<<<<<<<< * # make sure the blob is not deleted as long as this message exists * self._keep_refs.append(b) */ __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__Blob), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_b = ((struct __pyx_obj_8pyliblo3_6_liblo__Blob *)__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":1003 * b = _Blob(value) * # make sure the blob is not deleted as long as this message exists * self._keep_refs.append(b) # <<<<<<<<<<<<<< * lo_message_add_blob(self._message, (<_Blob>b)._blob) * else: */ if (unlikely(__pyx_v_self->_keep_refs == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); __PYX_ERR(0, 1003, __pyx_L1_error) } __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_self->_keep_refs, ((PyObject *)__pyx_v_b)); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 1003, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":1004 * # make sure the blob is not deleted as long as this message exists * self._keep_refs.append(b) * lo_message_add_blob(self._message, (<_Blob>b)._blob) # <<<<<<<<<<<<<< * else: * raise TypeError("unknown OSC data type '%c'" % t) */ lo_message_add_blob(__pyx_v_self->_message, __pyx_v_b->_blob); /* "pyliblo3/_liblo.pyx":1000 * elif t == 't': * lo_message_add_timetag(self._message, _double_to_timetag(value)) * elif t == 'b': # <<<<<<<<<<<<<< * b = _Blob(value) * # make sure the blob is not deleted as long as this message exists */ break; default: /* "pyliblo3/_liblo.pyx":1006 * lo_message_add_blob(self._message, (<_Blob>b)._blob) * else: * raise TypeError("unknown OSC data type '%c'" % t) # <<<<<<<<<<<<<< * * cdef _add_auto(self, value): */ __pyx_t_2 = __Pyx_PyInt_From_char(__pyx_v_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_unknown_OSC_data_type_c, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 1006, __pyx_L1_error) break; } /* "pyliblo3/_liblo.pyx":964 * self._add_auto(arg) * * cdef _add(self, type, value): # <<<<<<<<<<<<<< * cdef uint8_t midi[4] * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyliblo3._liblo.Message._add", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_s); __Pyx_XDECREF((PyObject *)__pyx_v_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":1008 * raise TypeError("unknown OSC data type '%c'" % t) * * cdef _add_auto(self, value): # <<<<<<<<<<<<<< * # bool is a subclass of int, so check those first * if value is True: */ static PyObject *__pyx_f_8pyliblo3_6_liblo_7Message__add_auto(struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, PyObject *__pyx_v_value) { PyObject *__pyx_v_s = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int32_t __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int64_t __pyx_t_11; double __pyx_t_12; char *__pyx_t_13; PyObject *__pyx_t_14 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_add_auto", 1); /* "pyliblo3/_liblo.pyx":1010 * cdef _add_auto(self, value): * # bool is a subclass of int, so check those first * if value is True: # <<<<<<<<<<<<<< * lo_message_add_true(self._message) * elif value is False: */ __pyx_t_1 = (__pyx_v_value == Py_True); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":1011 * # bool is a subclass of int, so check those first * if value is True: * lo_message_add_true(self._message) # <<<<<<<<<<<<<< * elif value is False: * lo_message_add_false(self._message) */ lo_message_add_true(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":1010 * cdef _add_auto(self, value): * # bool is a subclass of int, so check those first * if value is True: # <<<<<<<<<<<<<< * lo_message_add_true(self._message) * elif value is False: */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1012 * if value is True: * lo_message_add_true(self._message) * elif value is False: # <<<<<<<<<<<<<< * lo_message_add_false(self._message) * elif isinstance(value, (int, long)): */ __pyx_t_1 = (__pyx_v_value == Py_False); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":1013 * lo_message_add_true(self._message) * elif value is False: * lo_message_add_false(self._message) # <<<<<<<<<<<<<< * elif isinstance(value, (int, long)): * try: */ lo_message_add_false(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":1012 * if value is True: * lo_message_add_true(self._message) * elif value is False: # <<<<<<<<<<<<<< * lo_message_add_false(self._message) * elif isinstance(value, (int, long)): */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1014 * elif value is False: * lo_message_add_false(self._message) * elif isinstance(value, (int, long)): # <<<<<<<<<<<<<< * try: * lo_message_add_int32(self._message, value) */ __pyx_t_2 = PyInt_Check(__pyx_v_value); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = PyLong_Check(__pyx_v_value); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":1015 * lo_message_add_false(self._message) * elif isinstance(value, (int, long)): * try: # <<<<<<<<<<<<<< * lo_message_add_int32(self._message, value) * except OverflowError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { /* "pyliblo3/_liblo.pyx":1016 * elif isinstance(value, (int, long)): * try: * lo_message_add_int32(self._message, value) # <<<<<<<<<<<<<< * except OverflowError: * lo_message_add_int64(self._message, value) */ __pyx_t_6 = __Pyx_PyInt_As_int32_t(__pyx_v_value); if (unlikely((__pyx_t_6 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1016, __pyx_L6_error) lo_message_add_int32(__pyx_v_self->_message, ((int32_t)__pyx_t_6)); /* "pyliblo3/_liblo.pyx":1015 * lo_message_add_false(self._message) * elif isinstance(value, (int, long)): * try: # <<<<<<<<<<<<<< * lo_message_add_int32(self._message, value) * except OverflowError: */ } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L11_try_end; __pyx_L6_error:; /* "pyliblo3/_liblo.pyx":1017 * try: * lo_message_add_int32(self._message, value) * except OverflowError: # <<<<<<<<<<<<<< * lo_message_add_int64(self._message, value) * elif isinstance(value, float): */ __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OverflowError); if (__pyx_t_7) { __Pyx_AddTraceback("pyliblo3._liblo.Message._add_auto", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(0, 1017, __pyx_L8_except_error) __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); /* "pyliblo3/_liblo.pyx":1018 * lo_message_add_int32(self._message, value) * except OverflowError: * lo_message_add_int64(self._message, value) # <<<<<<<<<<<<<< * elif isinstance(value, float): * lo_message_add_float(self._message, float(value)) */ __pyx_t_11 = __Pyx_PyInt_As_int64_t(__pyx_v_value); if (unlikely((__pyx_t_11 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1018, __pyx_L8_except_error) lo_message_add_int64(__pyx_v_self->_message, ((int64_t)__pyx_t_11)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L7_exception_handled; } goto __pyx_L8_except_error; /* "pyliblo3/_liblo.pyx":1015 * lo_message_add_false(self._message) * elif isinstance(value, (int, long)): * try: # <<<<<<<<<<<<<< * lo_message_add_int32(self._message, value) * except OverflowError: */ __pyx_L8_except_error:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L1_error; __pyx_L7_exception_handled:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); __pyx_L11_try_end:; } /* "pyliblo3/_liblo.pyx":1014 * elif value is False: * lo_message_add_false(self._message) * elif isinstance(value, (int, long)): # <<<<<<<<<<<<<< * try: * lo_message_add_int32(self._message, value) */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1019 * except OverflowError: * lo_message_add_int64(self._message, value) * elif isinstance(value, float): # <<<<<<<<<<<<<< * lo_message_add_float(self._message, float(value)) * elif isinstance(value, (bytes, unicode)): */ __pyx_t_1 = PyFloat_Check(__pyx_v_value); if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":1020 * lo_message_add_int64(self._message, value) * elif isinstance(value, float): * lo_message_add_float(self._message, float(value)) # <<<<<<<<<<<<<< * elif isinstance(value, (bytes, unicode)): * s = _encode(value) */ __pyx_t_12 = __Pyx_PyObject_AsDouble(__pyx_v_value); if (unlikely(__pyx_t_12 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1020, __pyx_L1_error) lo_message_add_float(__pyx_v_self->_message, __pyx_t_12); /* "pyliblo3/_liblo.pyx":1019 * except OverflowError: * lo_message_add_int64(self._message, value) * elif isinstance(value, float): # <<<<<<<<<<<<<< * lo_message_add_float(self._message, float(value)) * elif isinstance(value, (bytes, unicode)): */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1021 * elif isinstance(value, float): * lo_message_add_float(self._message, float(value)) * elif isinstance(value, (bytes, unicode)): # <<<<<<<<<<<<<< * s = _encode(value) * lo_message_add_string(self._message, s) */ __pyx_t_2 = PyBytes_Check(__pyx_v_value); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_t_2 = PyUnicode_Check(__pyx_v_value); __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":1022 * lo_message_add_float(self._message, float(value)) * elif isinstance(value, (bytes, unicode)): * s = _encode(value) # <<<<<<<<<<<<<< * lo_message_add_string(self._message, s) * elif value == None: */ __pyx_t_10 = __pyx_f_8pyliblo3_6_liblo__encode(__pyx_v_value); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1022, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_v_s = ((PyObject*)__pyx_t_10); __pyx_t_10 = 0; /* "pyliblo3/_liblo.pyx":1023 * elif isinstance(value, (bytes, unicode)): * s = _encode(value) * lo_message_add_string(self._message, s) # <<<<<<<<<<<<<< * elif value == None: * lo_message_add_nil(self._message) */ if (unlikely(__pyx_v_s == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 1023, __pyx_L1_error) } __pyx_t_13 = __Pyx_PyBytes_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_13) && PyErr_Occurred())) __PYX_ERR(0, 1023, __pyx_L1_error) lo_message_add_string(__pyx_v_self->_message, __pyx_t_13); /* "pyliblo3/_liblo.pyx":1021 * elif isinstance(value, float): * lo_message_add_float(self._message, float(value)) * elif isinstance(value, (bytes, unicode)): # <<<<<<<<<<<<<< * s = _encode(value) * lo_message_add_string(self._message, s) */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1024 * s = _encode(value) * lo_message_add_string(self._message, s) * elif value == None: # <<<<<<<<<<<<<< * lo_message_add_nil(self._message) * elif value == float('inf'): */ __pyx_t_10 = PyObject_RichCompare(__pyx_v_value, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1024, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1024, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":1025 * lo_message_add_string(self._message, s) * elif value == None: * lo_message_add_nil(self._message) # <<<<<<<<<<<<<< * elif value == float('inf'): * lo_message_add_infinitum(self._message) */ lo_message_add_nil(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":1024 * s = _encode(value) * lo_message_add_string(self._message, s) * elif value == None: # <<<<<<<<<<<<<< * lo_message_add_nil(self._message) * elif value == float('inf'): */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1026 * elif value == None: * lo_message_add_nil(self._message) * elif value == float('inf'): # <<<<<<<<<<<<<< * lo_message_add_infinitum(self._message) * else: */ __pyx_t_12 = __Pyx_PyString_AsDouble(__pyx_n_s_inf); if (unlikely(__pyx_t_12 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1026, __pyx_L1_error) __pyx_t_10 = PyFloat_FromDouble(__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1026, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_9 = PyObject_RichCompare(__pyx_v_value, __pyx_t_10, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1026, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1026, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__pyx_t_1) { /* "pyliblo3/_liblo.pyx":1027 * lo_message_add_nil(self._message) * elif value == float('inf'): * lo_message_add_infinitum(self._message) # <<<<<<<<<<<<<< * else: * # last chance: could be a blob */ lo_message_add_infinitum(__pyx_v_self->_message); /* "pyliblo3/_liblo.pyx":1026 * elif value == None: * lo_message_add_nil(self._message) * elif value == float('inf'): # <<<<<<<<<<<<<< * lo_message_add_infinitum(self._message) * else: */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1030 * else: * # last chance: could be a blob * try: # <<<<<<<<<<<<<< * iter(value) * except TypeError: */ /*else*/ { { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "pyliblo3/_liblo.pyx":1031 * # last chance: could be a blob * try: * iter(value) # <<<<<<<<<<<<<< * except TypeError: * raise TypeError("unsupported message argument type") */ __pyx_t_9 = PyObject_GetIter(__pyx_v_value); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1031, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "pyliblo3/_liblo.pyx":1030 * else: * # last chance: could be a blob * try: # <<<<<<<<<<<<<< * iter(value) * except TypeError: */ } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L21_try_end; __pyx_L16_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "pyliblo3/_liblo.pyx":1032 * try: * iter(value) * except TypeError: # <<<<<<<<<<<<<< * raise TypeError("unsupported message argument type") * self._add('b', value) */ __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_7) { __Pyx_AddTraceback("pyliblo3._liblo.Message._add_auto", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_8) < 0) __PYX_ERR(0, 1032, __pyx_L18_except_error) __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_8); /* "pyliblo3/_liblo.pyx":1033 * iter(value) * except TypeError: * raise TypeError("unsupported message argument type") # <<<<<<<<<<<<<< * self._add('b', value) * */ __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1033, __pyx_L18_except_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_Raise(__pyx_t_14, 0, 0, 0); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __PYX_ERR(0, 1033, __pyx_L18_except_error) } goto __pyx_L18_except_error; /* "pyliblo3/_liblo.pyx":1030 * else: * # last chance: could be a blob * try: # <<<<<<<<<<<<<< * iter(value) * except TypeError: */ __pyx_L18_except_error:; __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3); goto __pyx_L1_error; __pyx_L21_try_end:; } /* "pyliblo3/_liblo.pyx":1034 * except TypeError: * raise TypeError("unsupported message argument type") * self._add('b', value) # <<<<<<<<<<<<<< * * */ __pyx_t_8 = ((struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message *)__pyx_v_self->__pyx_vtab)->_add(__pyx_v_self, __pyx_n_s_b, __pyx_v_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1034, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __pyx_L3:; /* "pyliblo3/_liblo.pyx":1008 * raise TypeError("unknown OSC data type '%c'" % t) * * cdef _add_auto(self, value): # <<<<<<<<<<<<<< * # bool is a subclass of int, so check those first * if value is True: */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("pyliblo3._liblo.Message._add_auto", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_s); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Message_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_8pyliblo3_6_liblo_7Message_6__reduce_cython__, "Message.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Message_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Message_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Message_6__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Message_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_8pyliblo3_6_liblo_7Message_6__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Message *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_7Message_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self._message cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._message cannot be converted to a Python object for pickling" */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__message_cannot_be_converte, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Message.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Message_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_8pyliblo3_6_liblo_7Message_8__setstate_cython__, "Message.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7Message_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Message_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Message_8__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7Message_9__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 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(2, 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(2, 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("pyliblo3._liblo.Message.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_7Message_8__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Message *)__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_8pyliblo3_6_liblo_7Message_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._message cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__message_cannot_be_converte, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Message.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":1062 * cdef list _keep_refs * * def __init__(self, *messages): # <<<<<<<<<<<<<< * cdef lo_timetag tt * tt.sec, tt.frac = 0, 0 */ /* Python wrapper */ static int __pyx_pw_8pyliblo3_6_liblo_6Bundle_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_8pyliblo3_6_liblo_6Bundle_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_messages = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __Pyx_INCREF(__pyx_args); __pyx_v_messages = __pyx_args; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6Bundle___init__(((struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)__pyx_v_self), __pyx_v_messages); /* function exit code */ __Pyx_DECREF(__pyx_v_messages); __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_8pyliblo3_6_liblo_6Bundle___init__(struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self, PyObject *__pyx_v_messages) { lo_timetag __pyx_v_tt; PyObject *__pyx_v_t = NULL; int __pyx_r; __Pyx_RefNannyDeclarations uint32_t __pyx_t_1; uint32_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; Py_ssize_t __pyx_t_5; int __pyx_t_6; int __pyx_t_7; double __pyx_t_8; lo_timetag __pyx_t_9; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *(*__pyx_t_12)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); __Pyx_INCREF(__pyx_v_messages); /* "pyliblo3/_liblo.pyx":1064 * def __init__(self, *messages): * cdef lo_timetag tt * tt.sec, tt.frac = 0, 0 # <<<<<<<<<<<<<< * self._keep_refs = [] * */ __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_v_tt.sec = __pyx_t_1; __pyx_v_tt.frac = __pyx_t_2; /* "pyliblo3/_liblo.pyx":1065 * cdef lo_timetag tt * tt.sec, tt.frac = 0, 0 * self._keep_refs = [] # <<<<<<<<<<<<<< * * if len(messages) and not isinstance(messages[0], Message): */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1065, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->_keep_refs); __Pyx_DECREF(__pyx_v_self->_keep_refs); __pyx_v_self->_keep_refs = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":1067 * self._keep_refs = [] * * if len(messages) and not isinstance(messages[0], Message): # <<<<<<<<<<<<<< * t = messages[0] * if isinstance(t, (float, int, long)): */ __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_messages); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1067, __pyx_L1_error) __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { } else { __pyx_t_4 = __pyx_t_6; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = __Pyx_GetItemInt_Tuple(__pyx_v_messages, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_TypeCheck(__pyx_t_3, __pyx_ptype_8pyliblo3_6_liblo_Message); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_7 = (!__pyx_t_6); __pyx_t_4 = __pyx_t_7; __pyx_L4_bool_binop_done:; if (__pyx_t_4) { /* "pyliblo3/_liblo.pyx":1068 * * if len(messages) and not isinstance(messages[0], Message): * t = messages[0] # <<<<<<<<<<<<<< * if isinstance(t, (float, int, long)): * tt = _double_to_timetag(t) */ __pyx_t_3 = __Pyx_GetItemInt_Tuple(__pyx_v_messages, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1068, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_t = __pyx_t_3; __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":1069 * if len(messages) and not isinstance(messages[0], Message): * t = messages[0] * if isinstance(t, (float, int, long)): # <<<<<<<<<<<<<< * tt = _double_to_timetag(t) * elif isinstance(t, tuple) and len(t) == 2: */ __pyx_t_7 = PyFloat_Check(__pyx_v_t); if (!__pyx_t_7) { } else { __pyx_t_4 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = PyInt_Check(__pyx_v_t); if (!__pyx_t_7) { } else { __pyx_t_4 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = PyLong_Check(__pyx_v_t); __pyx_t_4 = __pyx_t_7; __pyx_L7_bool_binop_done:; if (__pyx_t_4) { /* "pyliblo3/_liblo.pyx":1070 * t = messages[0] * if isinstance(t, (float, int, long)): * tt = _double_to_timetag(t) # <<<<<<<<<<<<<< * elif isinstance(t, tuple) and len(t) == 2: * tt.sec, tt.frac = t */ __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_t); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1070, __pyx_L1_error) __pyx_t_9 = __pyx_f_8pyliblo3_6_liblo__double_to_timetag(__pyx_t_8); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1070, __pyx_L1_error) __pyx_v_tt = __pyx_t_9; /* "pyliblo3/_liblo.pyx":1069 * if len(messages) and not isinstance(messages[0], Message): * t = messages[0] * if isinstance(t, (float, int, long)): # <<<<<<<<<<<<<< * tt = _double_to_timetag(t) * elif isinstance(t, tuple) and len(t) == 2: */ goto __pyx_L6; } /* "pyliblo3/_liblo.pyx":1071 * if isinstance(t, (float, int, long)): * tt = _double_to_timetag(t) * elif isinstance(t, tuple) and len(t) == 2: # <<<<<<<<<<<<<< * tt.sec, tt.frac = t * else: */ __pyx_t_7 = PyTuple_Check(__pyx_v_t); if (__pyx_t_7) { } else { __pyx_t_4 = __pyx_t_7; goto __pyx_L10_bool_binop_done; } __pyx_t_5 = PyObject_Length(__pyx_v_t); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1071, __pyx_L1_error) __pyx_t_7 = (__pyx_t_5 == 2); __pyx_t_4 = __pyx_t_7; __pyx_L10_bool_binop_done:; if (likely(__pyx_t_4)) { /* "pyliblo3/_liblo.pyx":1072 * tt = _double_to_timetag(t) * elif isinstance(t, tuple) and len(t) == 2: * tt.sec, tt.frac = t # <<<<<<<<<<<<<< * else: * raise TypeError("invalid timetag") */ if ((likely(PyTuple_CheckExact(__pyx_v_t))) || (PyList_CheckExact(__pyx_v_t))) { PyObject* sequence = __pyx_v_t; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 1072, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_3 = PyList_GET_ITEM(sequence, 0); __pyx_t_10 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_10); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); #endif } else { Py_ssize_t index = -1; __pyx_t_11 = PyObject_GetIter(__pyx_v_t); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1072, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_12 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_11); index = 0; __pyx_t_3 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_3)) goto __pyx_L12_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); index = 1; __pyx_t_10 = __pyx_t_12(__pyx_t_11); if (unlikely(!__pyx_t_10)) goto __pyx_L12_unpacking_failed; __Pyx_GOTREF(__pyx_t_10); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_11), 2) < 0) __PYX_ERR(0, 1072, __pyx_L1_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L13_unpacking_done; __pyx_L12_unpacking_failed:; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 1072, __pyx_L1_error) __pyx_L13_unpacking_done:; } __pyx_t_2 = __Pyx_PyInt_As_uint32_t(__pyx_t_3); if (unlikely((__pyx_t_2 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1072, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyInt_As_uint32_t(__pyx_t_10); if (unlikely((__pyx_t_1 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1072, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_tt.sec = __pyx_t_2; __pyx_v_tt.frac = __pyx_t_1; /* "pyliblo3/_liblo.pyx":1071 * if isinstance(t, (float, int, long)): * tt = _double_to_timetag(t) * elif isinstance(t, tuple) and len(t) == 2: # <<<<<<<<<<<<<< * tt.sec, tt.frac = t * else: */ goto __pyx_L6; } /* "pyliblo3/_liblo.pyx":1074 * tt.sec, tt.frac = t * else: * raise TypeError("invalid timetag") # <<<<<<<<<<<<<< * # first argument was timetag, so continue with second * messages = messages[1:] */ /*else*/ { __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1074, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __PYX_ERR(0, 1074, __pyx_L1_error) } __pyx_L6:; /* "pyliblo3/_liblo.pyx":1076 * raise TypeError("invalid timetag") * # first argument was timetag, so continue with second * messages = messages[1:] # <<<<<<<<<<<<<< * * self._bundle = lo_bundle_new(tt) */ __pyx_t_10 = __Pyx_PyTuple_GetSlice(__pyx_v_messages, 1, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1076, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF_SET(__pyx_v_messages, ((PyObject*)__pyx_t_10)); __pyx_t_10 = 0; /* "pyliblo3/_liblo.pyx":1067 * self._keep_refs = [] * * if len(messages) and not isinstance(messages[0], Message): # <<<<<<<<<<<<<< * t = messages[0] * if isinstance(t, (float, int, long)): */ } /* "pyliblo3/_liblo.pyx":1078 * messages = messages[1:] * * self._bundle = lo_bundle_new(tt) # <<<<<<<<<<<<<< * if len(messages): * self.add(*messages) */ __pyx_v_self->_bundle = lo_bundle_new(__pyx_v_tt); /* "pyliblo3/_liblo.pyx":1079 * * self._bundle = lo_bundle_new(tt) * if len(messages): # <<<<<<<<<<<<<< * self.add(*messages) * */ __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_messages); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1079, __pyx_L1_error) __pyx_t_4 = (__pyx_t_5 != 0); if (__pyx_t_4) { /* "pyliblo3/_liblo.pyx":1080 * self._bundle = lo_bundle_new(tt) * if len(messages): * self.add(*messages) # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_v_messages, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":1079 * * self._bundle = lo_bundle_new(tt) * if len(messages): # <<<<<<<<<<<<<< * self.add(*messages) * */ } /* "pyliblo3/_liblo.pyx":1062 * cdef list _keep_refs * * def __init__(self, *messages): # <<<<<<<<<<<<<< * cdef lo_timetag tt * tt.sec, tt.frac = 0, 0 */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("pyliblo3._liblo.Bundle.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_messages); __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyliblo3/_liblo.pyx":1082 * self.add(*messages) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_bundle_free(self._bundle) * */ /* Python wrapper */ static void __pyx_pw_8pyliblo3_6_liblo_6Bundle_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_8pyliblo3_6_liblo_6Bundle_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_8pyliblo3_6_liblo_6Bundle_2__dealloc__(((struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_8pyliblo3_6_liblo_6Bundle_2__dealloc__(struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self) { /* "pyliblo3/_liblo.pyx":1083 * * def __dealloc__(self): * lo_bundle_free(self._bundle) # <<<<<<<<<<<<<< * * def add(self, *args): */ lo_bundle_free(__pyx_v_self->_bundle); /* "pyliblo3/_liblo.pyx":1082 * self.add(*messages) * * def __dealloc__(self): # <<<<<<<<<<<<<< * lo_bundle_free(self._bundle) * */ /* function exit code */ } /* "pyliblo3/_liblo.pyx":1085 * lo_bundle_free(self._bundle) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Add one or more messages to this bundle */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Bundle_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ PyDoc_STRVAR(__pyx_doc_8pyliblo3_6_liblo_6Bundle_4add, "Bundle.add(self, *args)\n\n Add one or more messages to this bundle\n\n Possible forms:\n\n * `add(*messages: Message)`\n * `add(path: str, *args)`, where path is the osc path (for example, '/path1' or '/root/subpath')\n and `args` are passed directly to `Message` to create a Message to be added to this Bundle\n\n Add one or more messages to the bundle.\n "); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6Bundle_5add = {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Bundle_5add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Bundle_4add}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Bundle_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_args = 0; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "add", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_args = __pyx_args; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6Bundle_4add(((struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)__pyx_v_self), __pyx_v_args); /* function exit code */ __Pyx_DECREF(__pyx_v_args); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Bundle_4add(struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self, PyObject *__pyx_v_args) { PyObject *__pyx_v_messages = NULL; PyObject *__pyx_v_m = NULL; struct __pyx_obj_8pyliblo3_6_liblo_Message *__pyx_v_message = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *(*__pyx_t_5)(PyObject *); int __pyx_t_6; char *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add", 1); /* "pyliblo3/_liblo.pyx":1097 * Add one or more messages to the bundle. * """ * if isinstance(args[0], Message): # <<<<<<<<<<<<<< * # args is already a list of Messages * messages = args */ __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_TypeCheck(__pyx_t_1, __pyx_ptype_8pyliblo3_6_liblo_Message); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "pyliblo3/_liblo.pyx":1099 * if isinstance(args[0], Message): * # args is already a list of Messages * messages = args # <<<<<<<<<<<<<< * else: * # make a single Message from all arguments */ __Pyx_INCREF(__pyx_v_args); __pyx_v_messages = __pyx_v_args; /* "pyliblo3/_liblo.pyx":1097 * Add one or more messages to the bundle. * """ * if isinstance(args[0], Message): # <<<<<<<<<<<<<< * # args is already a list of Messages * messages = args */ goto __pyx_L3; } /* "pyliblo3/_liblo.pyx":1102 * else: * # make a single Message from all arguments * messages = [Message(*args)] # <<<<<<<<<<<<<< * * # add all messages */ /*else*/ { __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Message), __pyx_v_args, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(0, 1102, __pyx_L1_error); __pyx_t_1 = 0; __pyx_v_messages = __pyx_t_3; __pyx_t_3 = 0; } __pyx_L3:; /* "pyliblo3/_liblo.pyx":1105 * * # add all messages * for m in messages: # <<<<<<<<<<<<<< * self._keep_refs.append(m) * message = m */ if (likely(PyList_CheckExact(__pyx_v_messages)) || PyTuple_CheckExact(__pyx_v_messages)) { __pyx_t_3 = __pyx_v_messages; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_messages); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1105, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_5)) { if (likely(PyList_CheckExact(__pyx_t_3))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1105, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 1105, __pyx_L1_error) #else __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1105, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 1105, __pyx_L1_error) #else __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_5(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 1105, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_1); } __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_1); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":1106 * # add all messages * for m in messages: * self._keep_refs.append(m) # <<<<<<<<<<<<<< * message = m * lo_bundle_add_message(self._bundle, message._path, message._message) */ if (unlikely(__pyx_v_self->_keep_refs == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); __PYX_ERR(0, 1106, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_self->_keep_refs, __pyx_v_m); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 1106, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":1107 * for m in messages: * self._keep_refs.append(m) * message = m # <<<<<<<<<<<<<< * lo_bundle_add_message(self._bundle, message._path, message._message) */ __pyx_t_1 = __pyx_v_m; __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_message, ((struct __pyx_obj_8pyliblo3_6_liblo_Message *)__pyx_t_1)); __pyx_t_1 = 0; /* "pyliblo3/_liblo.pyx":1108 * self._keep_refs.append(m) * message = m * lo_bundle_add_message(self._bundle, message._path, message._message) # <<<<<<<<<<<<<< */ if (unlikely(__pyx_v_message->_path == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(0, 1108, __pyx_L1_error) } __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_message->_path); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 1108, __pyx_L1_error) lo_bundle_add_message(__pyx_v_self->_bundle, __pyx_t_7, __pyx_v_message->_message); /* "pyliblo3/_liblo.pyx":1105 * * # add all messages * for m in messages: # <<<<<<<<<<<<<< * self._keep_refs.append(m) * message = m */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":1085 * lo_bundle_free(self._bundle) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Add one or more messages to this bundle */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyliblo3._liblo.Bundle.add", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_messages); __Pyx_XDECREF(__pyx_v_m); __Pyx_XDECREF((PyObject *)__pyx_v_message); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Bundle_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_8pyliblo3_6_liblo_6Bundle_6__reduce_cython__, "Bundle.__reduce_cython__(self)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6Bundle_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Bundle_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Bundle_6__reduce_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Bundle_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_8pyliblo3_6_liblo_6Bundle_6__reduce_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_6Bundle_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__bundle_cannot_be_converted, 0, 0); __PYX_ERR(2, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Bundle.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Bundle_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_8pyliblo3_6_liblo_6Bundle_8__setstate_cython__, "Bundle.__setstate_cython__(self, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_6Bundle_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Bundle_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Bundle_8__setstate_cython__}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_6Bundle_9__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 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(2, 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(2, 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("pyliblo3._liblo.Bundle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6Bundle_8__setstate_cython__(((struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)__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_8pyliblo3_6_liblo_6Bundle_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_8pyliblo3_6_liblo_Bundle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__bundle_cannot_be_converted, 0, 0); __PYX_ERR(2, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyliblo3._liblo.Bundle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle_Callback(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_8pyliblo3_6_liblo_7__pyx_unpickle_Callback(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_8pyliblo3_6_liblo_6__pyx_unpickle_Callback, "__pyx_unpickle_Callback(__pyx_type, long __pyx_checksum, __pyx_state)"); static PyMethodDef __pyx_mdef_8pyliblo3_6_liblo_7__pyx_unpickle_Callback = {"__pyx_unpickle_Callback", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7__pyx_unpickle_Callback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6__pyx_unpickle_Callback}; static PyObject *__pyx_pw_8pyliblo3_6_liblo_7__pyx_unpickle_Callback(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_Callback (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Callback", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Callback", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Callback") < 0)) __PYX_ERR(2, 1, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Callback", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 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("pyliblo3._liblo.__pyx_unpickle_Callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_8pyliblo3_6_liblo_6__pyx_unpickle_Callback(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_8pyliblo3_6_liblo_6__pyx_unpickle_Callback(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Callback", 1); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb933e34, 0x7cc8780, 0x302b03a): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__10, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0xb933e34, 0x7cc8780, 0x302b03a): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum * __pyx_result = Callback.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(2, 5, __pyx_L1_error); __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0xb933e34, 0x7cc8780, 0x302b03a): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum # <<<<<<<<<<<<<< * __pyx_result = Callback.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(2, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb933e34, 0x7cc8780, 0x302b03a): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum * __pyx_result = Callback.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_Callback__set_state( __pyx_result, __pyx_state) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Callback), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 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 (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum * __pyx_result = Callback.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Callback__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_2 = (__pyx_v___pyx_state != Py_None); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = Callback.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_Callback__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_Callback__set_state(Callback __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(2, 9, __pyx_L1_error) __pyx_t_1 = __pyx_f_8pyliblo3_6_liblo___pyx_unpickle_Callback__set_state(((struct __pyx_obj_8pyliblo3_6_liblo_Callback *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 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 (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum * __pyx_result = Callback.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Callback__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_Callback__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_Callback__set_state(Callback __pyx_result, tuple __pyx_state): * __pyx_result.func = __pyx_state[0]; __pyx_result.has_varargs = __pyx_state[1]; __pyx_result.numargs = __pyx_state[2]; __pyx_result.user_data = __pyx_state[3] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_Callback(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyliblo3._liblo.__pyx_unpickle_Callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_Callback__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Callback__set_state(Callback __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.func = __pyx_state[0]; __pyx_result.has_varargs = __pyx_state[1]; __pyx_result.numargs = __pyx_state[2]; __pyx_result.user_data = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_8pyliblo3_6_liblo___pyx_unpickle_Callback__set_state(struct __pyx_obj_8pyliblo3_6_liblo_Callback *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Callback__set_state", 1); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_Callback__set_state(Callback __pyx_result, tuple __pyx_state): * __pyx_result.func = __pyx_state[0]; __pyx_result.has_varargs = __pyx_state[1]; __pyx_result.numargs = __pyx_state[2]; __pyx_result.user_data = __pyx_state[3] # <<<<<<<<<<<<<< * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(2, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->func); __Pyx_DECREF(__pyx_v___pyx_result->func); __pyx_v___pyx_result->func = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(2, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->has_varargs = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(2, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->numargs = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(2, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->user_data); __Pyx_DECREF(__pyx_v___pyx_result->user_data); __pyx_v___pyx_result->user_data = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_Callback__set_state(Callback __pyx_result, tuple __pyx_state): * __pyx_result.func = __pyx_state[0]; __pyx_result.has_varargs = __pyx_state[1]; __pyx_result.numargs = __pyx_state[2]; __pyx_result.user_data = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(2, 13, __pyx_L1_error) } __pyx_t_4 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error) __pyx_t_5 = (__pyx_t_4 > 4); if (__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) __pyx_t_3 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (__pyx_t_3) { /* "(tree fragment)":14 * __pyx_result.func = __pyx_state[0]; __pyx_result.has_varargs = __pyx_state[1]; __pyx_result.numargs = __pyx_state[2]; __pyx_result.user_data = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) # <<<<<<<<<<<<<< */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(2, 14, __pyx_L1_error) } __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; __pyx_t_2 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_2 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_6}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_Callback__set_state(Callback __pyx_result, tuple __pyx_state): * __pyx_result.func = __pyx_state[0]; __pyx_result.has_varargs = __pyx_state[1]; __pyx_result.numargs = __pyx_state[2]; __pyx_result.user_data = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ } /* "(tree fragment)":11 * __pyx_unpickle_Callback__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Callback__set_state(Callback __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.func = __pyx_state[0]; __pyx_result.has_varargs = __pyx_state[1]; __pyx_result.numargs = __pyx_state[2]; __pyx_result.user_data = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("pyliblo3._liblo.__pyx_unpickle_Callback__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Callback(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_8pyliblo3_6_liblo_Callback *p; PyObject *o; #if CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif p = ((struct __pyx_obj_8pyliblo3_6_liblo_Callback *)o); p->func = Py_None; Py_INCREF(Py_None); p->user_data = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo_Callback(PyObject *o) { struct __pyx_obj_8pyliblo3_6_liblo_Callback *p = (struct __pyx_obj_8pyliblo3_6_liblo_Callback *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo_Callback) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->func); Py_CLEAR(p->user_data); #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_8pyliblo3_6_liblo_Callback(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8pyliblo3_6_liblo_Callback *p = (struct __pyx_obj_8pyliblo3_6_liblo_Callback *)o; if (p->func) { e = (*v)(p->func, a); if (e) return e; } if (p->user_data) { e = (*v)(p->user_data, a); if (e) return e; } return 0; } static int __pyx_tp_clear_8pyliblo3_6_liblo_Callback(PyObject *o) { PyObject* tmp; struct __pyx_obj_8pyliblo3_6_liblo_Callback *p = (struct __pyx_obj_8pyliblo3_6_liblo_Callback *)o; tmp = ((PyObject*)p->func); p->func = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->user_data); p->user_data = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_8pyliblo3_6_liblo_Callback[] = { {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_8Callback_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_8Callback_2__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_8Callback_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_8Callback_4__setstate_cython__}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo_Callback_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo_Callback}, {Py_tp_doc, (void *)PyDoc_STR("Callback(func, user_data)\n\n Used internally to wrap a python function as a callback\n\n Args:\n func: the function to call\n user_data: any python object, will be passed to the callback as the last argument\n ")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8pyliblo3_6_liblo_Callback}, {Py_tp_clear, (void *)__pyx_tp_clear_8pyliblo3_6_liblo_Callback}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo_Callback}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_8Callback_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo_Callback}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo_Callback_spec = { "pyliblo3._liblo.Callback", sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Callback), 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_8pyliblo3_6_liblo_Callback_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo_Callback = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""Callback", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Callback), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo_Callback, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ PyDoc_STR("Callback(func, user_data)\n\n Used internally to wrap a python function as a callback\n\n Args:\n func: the function to call\n user_data: any python object, will be passed to the callback as the last argument\n "), /*tp_doc*/ __pyx_tp_traverse_8pyliblo3_6_liblo_Callback, /*tp_traverse*/ __pyx_tp_clear_8pyliblo3_6_liblo_Callback, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo_Callback, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_8Callback_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo_Callback, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase __pyx_vtable_8pyliblo3_6_liblo__ServerBase; static PyObject *__pyx_tp_new_8pyliblo3_6_liblo__ServerBase(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *p; PyObject *o; #if CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif p = ((struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)o); p->__pyx_vtab = __pyx_vtabptr_8pyliblo3_6_liblo__ServerBase; p->_keep_refs = ((PyObject*)Py_None); Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo__ServerBase(PyObject *o) { struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *p = (struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo__ServerBase) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->_keep_refs); #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_8pyliblo3_6_liblo__ServerBase(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *p = (struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)o; if (p->_keep_refs) { e = (*v)(p->_keep_refs, a); if (e) return e; } return 0; } static int __pyx_tp_clear_8pyliblo3_6_liblo__ServerBase(PyObject *o) { PyObject* tmp; struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *p = (struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *)o; tmp = ((PyObject*)p->_keep_refs); p->_keep_refs = ((PyObject*)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_8pyliblo3_6_liblo_11_ServerBase_url(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8pyliblo3_6_liblo_11_ServerBase_3url_1__get__(o); } static PyObject *__pyx_getprop_8pyliblo3_6_liblo_11_ServerBase_port(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8pyliblo3_6_liblo_11_ServerBase_4port_1__get__(o); } static PyObject *__pyx_getprop_8pyliblo3_6_liblo_11_ServerBase_protocol(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8pyliblo3_6_liblo_11_ServerBase_8protocol_1__get__(o); } static PyMethodDef __pyx_methods_8pyliblo3_6_liblo__ServerBase[] = { {"register_methods", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_3register_methods, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_2register_methods}, {"get_url", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_5get_url, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_4get_url}, {"get_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_7get_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_6get_port}, {"get_protocol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_9get_protocol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_8get_protocol}, {"fileno", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_11fileno, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_10fileno}, {"add_method", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_13add_method, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_12add_method}, {"del_method", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_15del_method, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_14del_method}, {"add_bundle_handlers", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_17add_bundle_handlers, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_16add_bundle_handlers}, {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_19send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_18send}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_20__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_11_ServerBase_22__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_8pyliblo3_6_liblo__ServerBase[] = { {(char *)"url", __pyx_getprop_8pyliblo3_6_liblo_11_ServerBase_url, 0, (char *)PyDoc_STR("\n The server's URL.\n "), 0}, {(char *)"port", __pyx_getprop_8pyliblo3_6_liblo_11_ServerBase_port, 0, (char *)PyDoc_STR("\n The server's port number (int)\n "), 0}, {(char *)"protocol", __pyx_getprop_8pyliblo3_6_liblo_11_ServerBase_protocol, 0, (char *)PyDoc_STR("\n The server's protocol (one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX`).\n "), 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo__ServerBase_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo__ServerBase}, {Py_tp_doc, (void *)PyDoc_STR("_ServerBase(reg_methods=True)")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8pyliblo3_6_liblo__ServerBase}, {Py_tp_clear, (void *)__pyx_tp_clear_8pyliblo3_6_liblo__ServerBase}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo__ServerBase}, {Py_tp_getset, (void *)__pyx_getsets_8pyliblo3_6_liblo__ServerBase}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_11_ServerBase_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo__ServerBase}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo__ServerBase_spec = { "pyliblo3._liblo._ServerBase", sizeof(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase), 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_8pyliblo3_6_liblo__ServerBase_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo__ServerBase = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""_ServerBase", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo__ServerBase, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ PyDoc_STR("_ServerBase(reg_methods=True)"), /*tp_doc*/ __pyx_tp_traverse_8pyliblo3_6_liblo__ServerBase, /*tp_traverse*/ __pyx_tp_clear_8pyliblo3_6_liblo__ServerBase, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo__ServerBase, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_8pyliblo3_6_liblo__ServerBase, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_11_ServerBase_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo__ServerBase, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Address(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; #if CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (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 return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo_Address(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo_Address) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_8pyliblo3_6_liblo_7Address_3__dealloc__(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_getprop_8pyliblo3_6_liblo_7Address_url(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8pyliblo3_6_liblo_7Address_3url_1__get__(o); } static PyObject *__pyx_getprop_8pyliblo3_6_liblo_7Address_hostname(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8pyliblo3_6_liblo_7Address_8hostname_1__get__(o); } static PyObject *__pyx_getprop_8pyliblo3_6_liblo_7Address_port(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8pyliblo3_6_liblo_7Address_4port_1__get__(o); } static PyObject *__pyx_getprop_8pyliblo3_6_liblo_7Address_protocol(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_8pyliblo3_6_liblo_7Address_8protocol_1__get__(o); } static PyMethodDef __pyx_methods_8pyliblo3_6_liblo_Address[] = { {"get_url", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_5get_url, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_4get_url}, {"get_hostname", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_7get_hostname, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_6get_hostname}, {"get_port", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_9get_port, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_8get_port}, {"get_protocol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_11get_protocol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_10get_protocol}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_12__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Address_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Address_14__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_8pyliblo3_6_liblo_Address[] = { {(char *)"url", __pyx_getprop_8pyliblo3_6_liblo_7Address_url, 0, (char *)PyDoc_STR("\n The address's URL.\n "), 0}, {(char *)"hostname", __pyx_getprop_8pyliblo3_6_liblo_7Address_hostname, 0, (char *)PyDoc_STR("\n The address's hostname.\n "), 0}, {(char *)"port", __pyx_getprop_8pyliblo3_6_liblo_7Address_port, 0, (char *)PyDoc_STR("\n The address's port number.\n "), 0}, {(char *)"protocol", __pyx_getprop_8pyliblo3_6_liblo_7Address_protocol, 0, (char *)PyDoc_STR("\n The address's protocol (one of the constants :const:`UDP`,\n :const:`TCP`, or :const:`UNIX`).\n "), 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo_Address_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo_Address}, {Py_tp_doc, (void *)PyDoc_STR("Address(addr, addr2=None, proto=LO_UDP)\n\n An Address represents a destination for a message\n\n Possible forms:\n\n * `Address(hostname: str, port: int, proto: [int | str] = LO_UDP`)\n * `Address(port: int)` # Assumes localhost\n * `Address(url: str)` # A URL of the form 'osc.udp://hostname:1234/'\n\n Create a new `Address` object from the given hostname/port\n or URL.\n\n Args:\n hostname: the target's hostname - the name or an IP of the form '127.0.0.0'.\n port: the port number of the target\n proto: one of the constants `LO_UDP`, `LO_TCP`, `LO_UNIX` or a string like 'UDP', 'TCP' or 'UNIX'\n url: a URL in liblo notation, e.g. `'osc.udp://hostname:1234/'`.\n\n Raises:\n AddressError: if the given parameters do not represent a valid address.\n\n ")}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo_Address}, {Py_tp_getset, (void *)__pyx_getsets_8pyliblo3_6_liblo_Address}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_7Address_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo_Address}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo_Address_spec = { "pyliblo3._liblo.Address", sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Address), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, __pyx_type_8pyliblo3_6_liblo_Address_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo_Address = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""Address", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Address), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo_Address, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ PyDoc_STR("Address(addr, addr2=None, proto=LO_UDP)\n\n An Address represents a destination for a message\n\n Possible forms:\n\n * `Address(hostname: str, port: int, proto: [int | str] = LO_UDP`)\n * `Address(port: int)` # Assumes localhost\n * `Address(url: str)` # A URL of the form 'osc.udp://hostname:1234/'\n\n Create a new `Address` object from the given hostname/port\n or URL.\n\n Args:\n hostname: the target's hostname - the name or an IP of the form '127.0.0.0'.\n port: the port number of the target\n proto: one of the constants `LO_UDP`, `LO_TCP`, `LO_UNIX` or a string like 'UDP', 'TCP' or 'UNIX'\n url: a URL in liblo notation, e.g. `'osc.udp://hostname:1234/'`.\n\n Raises:\n AddressError: if the given parameters do not represent a valid address.\n\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo_Address, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_8pyliblo3_6_liblo_Address, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_7Address_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo_Address, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static struct __pyx_vtabstruct_8pyliblo3_6_liblo_Message __pyx_vtable_8pyliblo3_6_liblo_Message; static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Message(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_8pyliblo3_6_liblo_Message *p; PyObject *o; #if CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif p = ((struct __pyx_obj_8pyliblo3_6_liblo_Message *)o); p->__pyx_vtab = __pyx_vtabptr_8pyliblo3_6_liblo_Message; p->_path = ((PyObject*)Py_None); Py_INCREF(Py_None); p->_keep_refs = ((PyObject*)Py_None); Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo_Message(PyObject *o) { struct __pyx_obj_8pyliblo3_6_liblo_Message *p = (struct __pyx_obj_8pyliblo3_6_liblo_Message *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo_Message) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_8pyliblo3_6_liblo_7Message_3__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->_path); Py_CLEAR(p->_keep_refs); #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_8pyliblo3_6_liblo_Message(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8pyliblo3_6_liblo_Message *p = (struct __pyx_obj_8pyliblo3_6_liblo_Message *)o; if (p->_keep_refs) { e = (*v)(p->_keep_refs, a); if (e) return e; } return 0; } static int __pyx_tp_clear_8pyliblo3_6_liblo_Message(PyObject *o) { PyObject* tmp; struct __pyx_obj_8pyliblo3_6_liblo_Message *p = (struct __pyx_obj_8pyliblo3_6_liblo_Message *)o; tmp = ((PyObject*)p->_keep_refs); p->_keep_refs = ((PyObject*)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_8pyliblo3_6_liblo_Message[] = { {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Message_5add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Message_4add}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Message_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Message_6__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_7Message_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_7Message_8__setstate_cython__}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo_Message_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo_Message}, {Py_tp_doc, (void *)PyDoc_STR("Message(path, *args)\n\n An OSC message, consisting of a path and arbitrary arguments.\n\n Args:\n path (str): the path of the message\n args: any arguments passed will be added to this messag\n ")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8pyliblo3_6_liblo_Message}, {Py_tp_clear, (void *)__pyx_tp_clear_8pyliblo3_6_liblo_Message}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo_Message}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_7Message_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo_Message}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo_Message_spec = { "pyliblo3._liblo.Message", sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Message), 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_8pyliblo3_6_liblo_Message_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo_Message = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""Message", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Message), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo_Message, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ PyDoc_STR("Message(path, *args)\n\n An OSC message, consisting of a path and arbitrary arguments.\n\n Args:\n path (str): the path of the message\n args: any arguments passed will be added to this messag\n "), /*tp_doc*/ __pyx_tp_traverse_8pyliblo3_6_liblo_Message, /*tp_traverse*/ __pyx_tp_clear_8pyliblo3_6_liblo_Message, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo_Message, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_7Message_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo_Message, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Bundle(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_8pyliblo3_6_liblo_Bundle *p; PyObject *o; #if CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif p = ((struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)o); p->_keep_refs = ((PyObject*)Py_None); Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo_Bundle(PyObject *o) { struct __pyx_obj_8pyliblo3_6_liblo_Bundle *p = (struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo_Bundle) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_8pyliblo3_6_liblo_6Bundle_3__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->_keep_refs); #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_8pyliblo3_6_liblo_Bundle(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_8pyliblo3_6_liblo_Bundle *p = (struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)o; if (p->_keep_refs) { e = (*v)(p->_keep_refs, a); if (e) return e; } return 0; } static int __pyx_tp_clear_8pyliblo3_6_liblo_Bundle(PyObject *o) { PyObject* tmp; struct __pyx_obj_8pyliblo3_6_liblo_Bundle *p = (struct __pyx_obj_8pyliblo3_6_liblo_Bundle *)o; tmp = ((PyObject*)p->_keep_refs); p->_keep_refs = ((PyObject*)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_8pyliblo3_6_liblo_Bundle[] = { {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Bundle_5add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Bundle_4add}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Bundle_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Bundle_6__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Bundle_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Bundle_8__setstate_cython__}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo_Bundle_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo_Bundle}, {Py_tp_doc, (void *)PyDoc_STR("Bundle(*messages)\n\n A bundle of one or more messages to be sent and dispatched together.\n\n Possible forms:\n\n * `Bundle(*messages)`\n * `Bundle(timetag: float, *messages)`\n\n Create a new `Bundle` object. You can optionally specify a\n time at which the messages should be dispatched (as an OSC timetag\n float), and any number of messages to be included in the bundle.\n\n Args:\n timetag (float): optional, speficies the time at which the message\n should be dispatched\n messages: any number of `Message`s to include in this `Bundle`\n ")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8pyliblo3_6_liblo_Bundle}, {Py_tp_clear, (void *)__pyx_tp_clear_8pyliblo3_6_liblo_Bundle}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo_Bundle}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_6Bundle_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo_Bundle}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo_Bundle_spec = { "pyliblo3._liblo.Bundle", sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Bundle), 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_8pyliblo3_6_liblo_Bundle_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo_Bundle = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""Bundle", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Bundle), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo_Bundle, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ PyDoc_STR("Bundle(*messages)\n\n A bundle of one or more messages to be sent and dispatched together.\n\n Possible forms:\n\n * `Bundle(*messages)`\n * `Bundle(timetag: float, *messages)`\n\n Create a new `Bundle` object. You can optionally specify a\n time at which the messages should be dispatched (as an OSC timetag\n float), and any number of messages to be included in the bundle.\n\n Args:\n timetag (float): optional, speficies the time at which the message\n should be dispatched\n messages: any number of `Message`s to include in this `Bundle`\n "), /*tp_doc*/ __pyx_tp_traverse_8pyliblo3_6_liblo_Bundle, /*tp_traverse*/ __pyx_tp_clear_8pyliblo3_6_liblo_Bundle, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo_Bundle, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_6Bundle_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo_Bundle, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static struct __pyx_vtabstruct_8pyliblo3_6_liblo_Server __pyx_vtable_8pyliblo3_6_liblo_Server; static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_Server(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_8pyliblo3_6_liblo_Server *p; PyObject *o = __pyx_tp_new_8pyliblo3_6_liblo__ServerBase(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_8pyliblo3_6_liblo_Server *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase*)__pyx_vtabptr_8pyliblo3_6_liblo_Server; return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo_Server(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo_Server) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_8pyliblo3_6_liblo_6Server_3__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } PyObject_GC_Track(o); __pyx_tp_dealloc_8pyliblo3_6_liblo__ServerBase(o); } static PyMethodDef __pyx_methods_8pyliblo3_6_liblo_Server[] = { {"free", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_5free, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_4free}, {"recv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_7recv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_6recv}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_8__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_6Server_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_6Server_10__setstate_cython__}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo_Server_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo_Server}, {Py_tp_doc, (void *)PyDoc_STR("Server(port=None, proto=LO_DEFAULT, reg_methods=True)\n\n A server that can receive OSC messages, blocking\n\n Use [ServerThread](#ServerThread) for an OSC server that runs in its own thread\n and never blocks.\n\n Args:\n port (int | None): a decimal port number or a UNIX socket path. If omitted, an\n arbitrary free UDP port will be used.\n proto (int | str): one of LO_UDP, LO_TCP, LO_UNIX or LO_DEFAULT, or one of the\n strings 'UDP', 'TCP', 'UNIX'\n reg_methods (bool): if True, register any methods decorated with the [make_method](#make_method)\n decorator\n\n Raises:\n ServerError: if an error occurs created the underlying liblo server\n\n ")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8pyliblo3_6_liblo__ServerBase}, {Py_tp_clear, (void *)__pyx_tp_clear_8pyliblo3_6_liblo__ServerBase}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo_Server}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_6Server_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo_Server}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo_Server_spec = { "pyliblo3._liblo.Server", sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Server), 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_8pyliblo3_6_liblo_Server_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo_Server = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""Server", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo_Server), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo_Server, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ PyDoc_STR("Server(port=None, proto=LO_DEFAULT, reg_methods=True)\n\n A server that can receive OSC messages, blocking\n\n Use [ServerThread](#ServerThread) for an OSC server that runs in its own thread\n and never blocks.\n\n Args:\n port (int | None): a decimal port number or a UNIX socket path. If omitted, an\n arbitrary free UDP port will be used.\n proto (int | str): one of LO_UDP, LO_TCP, LO_UNIX or LO_DEFAULT, or one of the\n strings 'UDP', 'TCP', 'UNIX'\n reg_methods (bool): if True, register any methods decorated with the [make_method](#make_method)\n decorator\n\n Raises:\n ServerError: if an error occurs created the underlying liblo server\n\n "), /*tp_doc*/ __pyx_tp_traverse_8pyliblo3_6_liblo__ServerBase, /*tp_traverse*/ __pyx_tp_clear_8pyliblo3_6_liblo__ServerBase, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo_Server, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_6Server_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo_Server, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static struct __pyx_vtabstruct_8pyliblo3_6_liblo_ServerThread __pyx_vtable_8pyliblo3_6_liblo_ServerThread; static PyObject *__pyx_tp_new_8pyliblo3_6_liblo_ServerThread(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *p; PyObject *o = __pyx_tp_new_8pyliblo3_6_liblo__ServerBase(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_8pyliblo3_6_liblo_ServerThread *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8pyliblo3_6_liblo__ServerBase*)__pyx_vtabptr_8pyliblo3_6_liblo_ServerThread; return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo_ServerThread(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo_ServerThread) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_8pyliblo3_6_liblo_12ServerThread_3__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } PyObject_GC_Track(o); __pyx_tp_dealloc_8pyliblo3_6_liblo__ServerBase(o); } static PyMethodDef __pyx_methods_8pyliblo3_6_liblo_ServerThread[] = { {"free", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_5free, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_4free}, {"start", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_7start, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_6start}, {"stop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_9stop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_8stop}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_10__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_12ServerThread_12__setstate_cython__}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo_ServerThread_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo_ServerThread}, {Py_tp_doc, (void *)PyDoc_STR("ServerThread(port=None, proto=LO_DEFAULT, reg_methods=True)\n\n Server running in a thread\n\n Unlike `Server`, `ServerThread` uses its own thread which\n runs in the background to dispatch messages. `ServerThread`\n has the same methods as `Server`, with the\n exception of `.recv`. Instead, it defines two additional\n methods `.start` and `.stop`.\n\n Args:\n port (int | str): a decimal port number or a UNIX socket path. If omitted, an\n arbitrary free UDP port will be used.\n proto (int | str): one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX` or\n a corresponding string 'UDP', 'TCP', 'UNIX'\n reg_methods: if True, register any method decorated with the [make_method](#make_method)\n decorator\n\n Raises:\n ServerError: if creating the server fails, e.g. because the given port could not\n be opened.\n\n !!! note\n\n Because liblo creates its own thread to receive and dispatch\n messages, callback functions will not be run in the main Python\n thread!\n\n ")}, {Py_tp_traverse, (void *)__pyx_tp_traverse_8pyliblo3_6_liblo__ServerBase}, {Py_tp_clear, (void *)__pyx_tp_clear_8pyliblo3_6_liblo__ServerBase}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo_ServerThread}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_12ServerThread_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo_ServerThread}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo_ServerThread_spec = { "pyliblo3._liblo.ServerThread", sizeof(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread), 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_8pyliblo3_6_liblo_ServerThread_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo_ServerThread = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""ServerThread", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo_ServerThread), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo_ServerThread, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ PyDoc_STR("ServerThread(port=None, proto=LO_DEFAULT, reg_methods=True)\n\n Server running in a thread\n\n Unlike `Server`, `ServerThread` uses its own thread which\n runs in the background to dispatch messages. `ServerThread`\n has the same methods as `Server`, with the\n exception of `.recv`. Instead, it defines two additional\n methods `.start` and `.stop`.\n\n Args:\n port (int | str): a decimal port number or a UNIX socket path. If omitted, an\n arbitrary free UDP port will be used.\n proto (int | str): one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX` or\n a corresponding string 'UDP', 'TCP', 'UNIX'\n reg_methods: if True, register any method decorated with the [make_method](#make_method)\n decorator\n\n Raises:\n ServerError: if creating the server fails, e.g. because the given port could not\n be opened.\n\n !!! note\n\n Because liblo creates its own thread to receive and dispatch\n messages, callback functions will not be run in the main Python\n thread!\n\n "), /*tp_doc*/ __pyx_tp_traverse_8pyliblo3_6_liblo__ServerBase, /*tp_traverse*/ __pyx_tp_clear_8pyliblo3_6_liblo__ServerBase, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo_ServerThread, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_12ServerThread_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo_ServerThread, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyObject *__pyx_tp_new_8pyliblo3_6_liblo__Blob(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; #if CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (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 return o; } static void __pyx_tp_dealloc_8pyliblo3_6_liblo__Blob(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_8pyliblo3_6_liblo__Blob) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_8pyliblo3_6_liblo_5_Blob_3__dealloc__(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_8pyliblo3_6_liblo__Blob[] = { {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_5_Blob_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_5_Blob_4__reduce_cython__}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8pyliblo3_6_liblo_5_Blob_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_8pyliblo3_6_liblo_5_Blob_6__setstate_cython__}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type_8pyliblo3_6_liblo__Blob_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_8pyliblo3_6_liblo__Blob}, {Py_tp_doc, (void *)PyDoc_STR("_Blob(arr)")}, {Py_tp_methods, (void *)__pyx_methods_8pyliblo3_6_liblo__Blob}, {Py_tp_init, (void *)__pyx_pw_8pyliblo3_6_liblo_5_Blob_1__init__}, {Py_tp_new, (void *)__pyx_tp_new_8pyliblo3_6_liblo__Blob}, {0, 0}, }; static PyType_Spec __pyx_type_8pyliblo3_6_liblo__Blob_spec = { "pyliblo3._liblo._Blob", sizeof(struct __pyx_obj_8pyliblo3_6_liblo__Blob), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, __pyx_type_8pyliblo3_6_liblo__Blob_slots, }; #else static PyTypeObject __pyx_type_8pyliblo3_6_liblo__Blob = { PyVarObject_HEAD_INIT(0, 0) "pyliblo3._liblo.""_Blob", /*tp_name*/ sizeof(struct __pyx_obj_8pyliblo3_6_liblo__Blob), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_8pyliblo3_6_liblo__Blob, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ PyDoc_STR("_Blob(arr)"), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_8pyliblo3_6_liblo__Blob, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __pyx_pw_8pyliblo3_6_liblo_5_Blob_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_8pyliblo3_6_liblo__Blob, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif /* #### Code section: pystring_table ### */ static int __Pyx_CreateStringTabAndInitStrings(void) { __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_0_16_1, __pyx_k_0_16_1, sizeof(__pyx_k_0_16_1), 0, 0, 1, 0}, {&__pyx_kp_s_A_decorator_that_serves_as_a_mo, __pyx_k_A_decorator_that_serves_as_a_mo, sizeof(__pyx_k_A_decorator_that_serves_as_a_mo), 0, 0, 1, 0}, {&__pyx_n_s_Address, __pyx_k_Address, sizeof(__pyx_k_Address), 0, 0, 1, 1}, {&__pyx_n_s_AddressError, __pyx_k_AddressError, sizeof(__pyx_k_AddressError), 0, 0, 1, 1}, {&__pyx_n_s_AddressError___init, __pyx_k_AddressError___init, sizeof(__pyx_k_AddressError___init), 0, 0, 1, 1}, {&__pyx_n_s_AddressError___str, __pyx_k_AddressError___str, sizeof(__pyx_k_AddressError___str), 0, 0, 1, 1}, {&__pyx_n_s_Address___reduce_cython, __pyx_k_Address___reduce_cython, sizeof(__pyx_k_Address___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_Address___setstate_cython, __pyx_k_Address___setstate_cython, sizeof(__pyx_k_Address___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_Address_get_hostname, __pyx_k_Address_get_hostname, sizeof(__pyx_k_Address_get_hostname), 0, 0, 1, 1}, {&__pyx_n_s_Address_get_port, __pyx_k_Address_get_port, sizeof(__pyx_k_Address_get_port), 0, 0, 1, 1}, {&__pyx_n_s_Address_get_protocol, __pyx_k_Address_get_protocol, sizeof(__pyx_k_Address_get_protocol), 0, 0, 1, 1}, {&__pyx_n_s_Address_get_url, __pyx_k_Address_get_url, sizeof(__pyx_k_Address_get_url), 0, 0, 1, 1}, {&__pyx_n_s_Blob, __pyx_k_Blob, sizeof(__pyx_k_Blob), 0, 0, 1, 1}, {&__pyx_n_s_Blob___reduce_cython, __pyx_k_Blob___reduce_cython, sizeof(__pyx_k_Blob___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_Blob___setstate_cython, __pyx_k_Blob___setstate_cython, sizeof(__pyx_k_Blob___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_Bundle, __pyx_k_Bundle, sizeof(__pyx_k_Bundle), 0, 0, 1, 1}, {&__pyx_n_s_Bundle___reduce_cython, __pyx_k_Bundle___reduce_cython, sizeof(__pyx_k_Bundle___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_Bundle___setstate_cython, __pyx_k_Bundle___setstate_cython, sizeof(__pyx_k_Bundle___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_Bundle_add, __pyx_k_Bundle_add, sizeof(__pyx_k_Bundle_add), 0, 0, 1, 1}, {&__pyx_n_s_Callback, __pyx_k_Callback, sizeof(__pyx_k_Callback), 0, 0, 1, 1}, {&__pyx_n_s_Callback___reduce_cython, __pyx_k_Callback___reduce_cython, sizeof(__pyx_k_Callback___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_Callback___setstate_cython, __pyx_k_Callback___setstate_cython, sizeof(__pyx_k_Callback___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_IOError, __pyx_k_IOError, sizeof(__pyx_k_IOError), 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_Message, __pyx_k_Message, sizeof(__pyx_k_Message), 0, 0, 1, 1}, {&__pyx_n_s_Message___reduce_cython, __pyx_k_Message___reduce_cython, sizeof(__pyx_k_Message___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_Message___setstate_cython, __pyx_k_Message___setstate_cython, sizeof(__pyx_k_Message___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_Message_add, __pyx_k_Message_add, sizeof(__pyx_k_Message_add), 0, 0, 1, 1}, {&__pyx_n_s_OverflowError, __pyx_k_OverflowError, sizeof(__pyx_k_OverflowError), 0, 0, 1, 1}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_kp_u_Proto, __pyx_k_Proto, sizeof(__pyx_k_Proto), 0, 1, 0, 0}, {&__pyx_kp_s_Raised_when_creating_a_liblo_OS, __pyx_k_Raised_when_creating_a_liblo_OS, sizeof(__pyx_k_Raised_when_creating_a_liblo_OS), 0, 0, 1, 0}, {&__pyx_kp_s_Raised_when_trying_to_create_an, __pyx_k_Raised_when_trying_to_create_an, sizeof(__pyx_k_Raised_when_trying_to_create_an), 0, 0, 1, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_Server, __pyx_k_Server, sizeof(__pyx_k_Server), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase, __pyx_k_ServerBase, sizeof(__pyx_k_ServerBase), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase___reduce_cython, __pyx_k_ServerBase___reduce_cython, sizeof(__pyx_k_ServerBase___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase___setstate_cython, __pyx_k_ServerBase___setstate_cython, sizeof(__pyx_k_ServerBase___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_add_bundle_handlers, __pyx_k_ServerBase_add_bundle_handlers, sizeof(__pyx_k_ServerBase_add_bundle_handlers), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_add_method, __pyx_k_ServerBase_add_method, sizeof(__pyx_k_ServerBase_add_method), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_del_method, __pyx_k_ServerBase_del_method, sizeof(__pyx_k_ServerBase_del_method), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_fileno, __pyx_k_ServerBase_fileno, sizeof(__pyx_k_ServerBase_fileno), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_get_port, __pyx_k_ServerBase_get_port, sizeof(__pyx_k_ServerBase_get_port), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_get_protocol, __pyx_k_ServerBase_get_protocol, sizeof(__pyx_k_ServerBase_get_protocol), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_get_url, __pyx_k_ServerBase_get_url, sizeof(__pyx_k_ServerBase_get_url), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_register_methods, __pyx_k_ServerBase_register_methods, sizeof(__pyx_k_ServerBase_register_methods), 0, 0, 1, 1}, {&__pyx_n_s_ServerBase_send, __pyx_k_ServerBase_send, sizeof(__pyx_k_ServerBase_send), 0, 0, 1, 1}, {&__pyx_n_s_ServerError, __pyx_k_ServerError, sizeof(__pyx_k_ServerError), 0, 0, 1, 1}, {&__pyx_n_s_ServerError___init, __pyx_k_ServerError___init, sizeof(__pyx_k_ServerError___init), 0, 0, 1, 1}, {&__pyx_n_s_ServerError___str, __pyx_k_ServerError___str, sizeof(__pyx_k_ServerError___str), 0, 0, 1, 1}, {&__pyx_n_s_ServerThread, __pyx_k_ServerThread, sizeof(__pyx_k_ServerThread), 0, 0, 1, 1}, {&__pyx_n_s_ServerThread___reduce_cython, __pyx_k_ServerThread___reduce_cython, sizeof(__pyx_k_ServerThread___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_ServerThread___setstate_cython, __pyx_k_ServerThread___setstate_cython, sizeof(__pyx_k_ServerThread___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_ServerThread_free, __pyx_k_ServerThread_free, sizeof(__pyx_k_ServerThread_free), 0, 0, 1, 1}, {&__pyx_n_s_ServerThread_start, __pyx_k_ServerThread_start, sizeof(__pyx_k_ServerThread_start), 0, 0, 1, 1}, {&__pyx_n_s_ServerThread_stop, __pyx_k_ServerThread_stop, sizeof(__pyx_k_ServerThread_stop), 0, 0, 1, 1}, {&__pyx_n_s_Server___reduce_cython, __pyx_k_Server___reduce_cython, sizeof(__pyx_k_Server___reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_Server___setstate_cython, __pyx_k_Server___setstate_cython, sizeof(__pyx_k_Server___setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_Server_free, __pyx_k_Server_free, sizeof(__pyx_k_Server_free), 0, 0, 1, 1}, {&__pyx_kp_s_Server_method_called_after_free, __pyx_k_Server_method_called_after_free, sizeof(__pyx_k_Server_method_called_after_free), 0, 0, 1, 0}, {&__pyx_n_s_Server_recv, __pyx_k_Server_recv, sizeof(__pyx_k_Server_recv), 0, 0, 1, 1}, {&__pyx_n_s_TCP, __pyx_k_TCP, sizeof(__pyx_k_TCP), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_UDP, __pyx_k_UDP, sizeof(__pyx_k_UDP), 0, 0, 1, 1}, {&__pyx_n_s_UNIX, __pyx_k_UNIX, sizeof(__pyx_k_UNIX), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_kp_s_Weak_reference_to_a_function_in, __pyx_k_Weak_reference_to_a_function_in, sizeof(__pyx_k_Weak_reference_to_a_function_in), 0, 0, 1, 0}, {&__pyx_kp_u__11, __pyx_k__11, sizeof(__pyx_k__11), 0, 1, 0, 0}, {&__pyx_n_s__12, __pyx_k__12, sizeof(__pyx_k__12), 0, 0, 1, 1}, {&__pyx_n_s__88, __pyx_k__88, sizeof(__pyx_k__88), 0, 0, 1, 1}, {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, {&__pyx_n_s_add_bundle_handlers, __pyx_k_add_bundle_handlers, sizeof(__pyx_k_add_bundle_handlers), 0, 0, 1, 1}, {&__pyx_n_s_add_method, __pyx_k_add_method, sizeof(__pyx_k_add_method), 0, 0, 1, 1}, {&__pyx_n_s_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 0, 1, 1}, {&__pyx_n_s_addr2, __pyx_k_addr2, sizeof(__pyx_k_addr2), 0, 0, 1, 1}, {&__pyx_kp_s_address_error_s, __pyx_k_address_error_s, sizeof(__pyx_k_address_error_s), 0, 0, 1, 0}, {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_arr, __pyx_k_arr, sizeof(__pyx_k_arr), 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, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, {&__pyx_kp_s_blob_is_empty, __pyx_k_blob_is_empty, sizeof(__pyx_k_blob_is_empty), 0, 0, 1, 0}, {&__pyx_n_s_call, __pyx_k_call, sizeof(__pyx_k_call), 0, 0, 1, 1}, {&__pyx_n_s_cb, __pyx_k_cb, sizeof(__pyx_k_cb), 0, 0, 1, 1}, {&__pyx_n_s_cb_data, __pyx_k_cb_data, sizeof(__pyx_k_cb_data), 0, 0, 1, 1}, {&__pyx_n_s_chr, __pyx_k_chr, sizeof(__pyx_k_chr), 0, 0, 1, 1}, {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_counter, __pyx_k_counter, sizeof(__pyx_k_counter), 0, 0, 1, 1}, {&__pyx_n_s_counter_2, __pyx_k_counter_2, sizeof(__pyx_k_counter_2), 0, 0, 1, 1}, {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, {&__pyx_n_s_del_method, __pyx_k_del_method, sizeof(__pyx_k_del_method), 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_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, {&__pyx_n_s_e, __pyx_k_e, sizeof(__pyx_k_e), 0, 0, 1, 1}, {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_end_func, __pyx_k_end_func, sizeof(__pyx_k_end_func), 0, 0, 1, 1}, {&__pyx_n_s_end_handler, __pyx_k_end_handler, sizeof(__pyx_k_end_handler), 0, 0, 1, 1}, {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1}, {&__pyx_n_s_fileno, __pyx_k_fileno, sizeof(__pyx_k_fileno), 0, 0, 1, 1}, {&__pyx_n_s_free, __pyx_k_free, sizeof(__pyx_k_free), 0, 0, 1, 1}, {&__pyx_n_s_func, __pyx_k_func, sizeof(__pyx_k_func), 0, 0, 1, 1}, {&__pyx_n_s_func_2, __pyx_k_func_2, sizeof(__pyx_k_func_2), 0, 0, 1, 1}, {&__pyx_n_s_func_3, __pyx_k_func_3, sizeof(__pyx_k_func_3), 0, 0, 1, 1}, {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_get_hostname, __pyx_k_get_hostname, sizeof(__pyx_k_get_hostname), 0, 0, 1, 1}, {&__pyx_n_s_get_port, __pyx_k_get_port, sizeof(__pyx_k_get_port), 0, 0, 1, 1}, {&__pyx_n_s_get_protocol, __pyx_k_get_protocol, sizeof(__pyx_k_get_protocol), 0, 0, 1, 1}, {&__pyx_n_s_get_url, __pyx_k_get_url, sizeof(__pyx_k_get_url), 0, 0, 1, 1}, {&__pyx_n_s_getfullargspec, __pyx_k_getfullargspec, sizeof(__pyx_k_getfullargspec), 0, 0, 1, 1}, {&__pyx_n_s_getmembers, __pyx_k_getmembers, sizeof(__pyx_k_getmembers), 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_kp_s_in_s, __pyx_k_in_s, sizeof(__pyx_k_in_s), 0, 0, 1, 0}, {&__pyx_n_s_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 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_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, {&__pyx_n_s_inspect, __pyx_k_inspect, sizeof(__pyx_k_inspect), 0, 0, 1, 1}, {&__pyx_n_s_inspect_2, __pyx_k_inspect_2, sizeof(__pyx_k_inspect_2), 0, 0, 1, 1}, {&__pyx_kp_s_invalid_URL_s, __pyx_k_invalid_URL_s, sizeof(__pyx_k_invalid_URL_s), 0, 0, 1, 0}, {&__pyx_kp_s_invalid_protocol, __pyx_k_invalid_protocol, sizeof(__pyx_k_invalid_protocol), 0, 0, 1, 0}, {&__pyx_kp_s_invalid_timetag, __pyx_k_invalid_timetag, sizeof(__pyx_k_invalid_timetag), 0, 0, 1, 0}, {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, {&__pyx_n_s_isdigit, __pyx_k_isdigit, sizeof(__pyx_k_isdigit), 0, 0, 1, 1}, {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, {&__pyx_n_s_ismethod, __pyx_k_ismethod, sizeof(__pyx_k_ismethod), 0, 0, 1, 1}, {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1}, {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1}, {&__pyx_n_s_m, __pyx_k_m, sizeof(__pyx_k_m), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_make_method, __pyx_k_make_method, sizeof(__pyx_k_make_method), 0, 0, 1, 1}, {&__pyx_n_s_make_method___call, __pyx_k_make_method___call, sizeof(__pyx_k_make_method___call), 0, 0, 1, 1}, {&__pyx_n_s_make_method___init, __pyx_k_make_method___init, sizeof(__pyx_k_make_method___init), 0, 0, 1, 1}, {&__pyx_n_s_message, __pyx_k_message, sizeof(__pyx_k_message), 0, 0, 1, 1}, {&__pyx_n_s_messages, __pyx_k_messages, sizeof(__pyx_k_messages), 0, 0, 1, 1}, {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, {&__pyx_n_s_method_spec, __pyx_k_method_spec, sizeof(__pyx_k_method_spec), 0, 0, 1, 1}, {&__pyx_n_s_methods, __pyx_k_methods, sizeof(__pyx_k_methods), 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_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_kp_u_not_understood_expected_one_of, __pyx_k_not_understood_expected_one_of, sizeof(__pyx_k_not_understood_expected_one_of), 0, 1, 0, 0}, {&__pyx_n_s_num, __pyx_k_num, sizeof(__pyx_k_num), 0, 0, 1, 1}, {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, {&__pyx_kp_s_path_must_be_a_string_or_None, __pyx_k_path_must_be_a_string_or_None, sizeof(__pyx_k_path_must_be_a_string_or_None), 0, 0, 1, 0}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 0, 1, 1}, {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, {&__pyx_n_s_property, __pyx_k_property, sizeof(__pyx_k_property), 0, 0, 1, 1}, {&__pyx_n_s_proto, __pyx_k_proto, sizeof(__pyx_k_proto), 0, 0, 1, 1}, {&__pyx_n_s_protostr_to_int, __pyx_k_protostr_to_int, sizeof(__pyx_k_protostr_to_int), 0, 0, 1, 1}, {&__pyx_n_s_pyliblo3__liblo, __pyx_k_pyliblo3__liblo, sizeof(__pyx_k_pyliblo3__liblo), 0, 0, 1, 1}, {&__pyx_kp_s_pyliblo3__liblo_pyx, __pyx_k_pyliblo3__liblo_pyx, sizeof(__pyx_k_pyliblo3__liblo_pyx), 0, 0, 1, 0}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_Callback, __pyx_k_pyx_unpickle_Callback, sizeof(__pyx_k_pyx_unpickle_Callback), 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_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, {&__pyx_n_s_recv, __pyx_k_recv, sizeof(__pyx_k_recv), 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_ref, __pyx_k_ref, sizeof(__pyx_k_ref), 0, 0, 1, 1}, {&__pyx_n_s_reg_methods, __pyx_k_reg_methods, sizeof(__pyx_k_reg_methods), 0, 0, 1, 1}, {&__pyx_n_s_register_methods, __pyx_k_register_methods, sizeof(__pyx_k_register_methods), 0, 0, 1, 1}, {&__pyx_n_s_register_methods_locals_lambda, __pyx_k_register_methods_locals_lambda, sizeof(__pyx_k_register_methods_locals_lambda), 0, 0, 1, 1}, {&__pyx_kp_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 0}, {&__pyx_n_s_s2, __pyx_k_s2, sizeof(__pyx_k_s2), 0, 0, 1, 1}, {&__pyx_n_s_s_2, __pyx_k_s_2, sizeof(__pyx_k_s_2), 0, 0, 1, 1}, {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, {&__pyx_n_s_self_2, __pyx_k_self_2, sizeof(__pyx_k_self_2), 0, 0, 1, 1}, {&__pyx_kp_s_self__address_cannot_be_converte, __pyx_k_self__address_cannot_be_converte, sizeof(__pyx_k_self__address_cannot_be_converte), 0, 0, 1, 0}, {&__pyx_kp_s_self__blob_cannot_be_converted_t, __pyx_k_self__blob_cannot_be_converted_t, sizeof(__pyx_k_self__blob_cannot_be_converted_t), 0, 0, 1, 0}, {&__pyx_kp_s_self__bundle_cannot_be_converted, __pyx_k_self__bundle_cannot_be_converted, sizeof(__pyx_k_self__bundle_cannot_be_converted), 0, 0, 1, 0}, {&__pyx_kp_s_self__message_cannot_be_converte, __pyx_k_self__message_cannot_be_converte, sizeof(__pyx_k_self__message_cannot_be_converte), 0, 0, 1, 0}, {&__pyx_kp_s_self__server_cannot_be_converted, __pyx_k_self__server_cannot_be_converted, sizeof(__pyx_k_self__server_cannot_be_converted), 0, 0, 1, 0}, {&__pyx_kp_s_self__server_self__server_thread, __pyx_k_self__server_self__server_thread, sizeof(__pyx_k_self__server_self__server_thread), 0, 0, 1, 0}, {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, {&__pyx_kp_s_sending_failed_s, __pyx_k_sending_failed_s, sizeof(__pyx_k_sending_failed_s), 0, 0, 1, 0}, {&__pyx_kp_s_server_error_d, __pyx_k_server_error_d, sizeof(__pyx_k_server_error_d), 0, 0, 1, 0}, {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 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_slots, __pyx_k_slots, sizeof(__pyx_k_slots), 0, 0, 1, 1}, {&__pyx_n_s_sort, __pyx_k_sort, sizeof(__pyx_k_sort), 0, 0, 1, 1}, {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, {&__pyx_n_s_spec_2, __pyx_k_spec_2, sizeof(__pyx_k_spec_2), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_start_func, __pyx_k_start_func, sizeof(__pyx_k_start_func), 0, 0, 1, 1}, {&__pyx_n_s_start_handler, __pyx_k_start_handler, sizeof(__pyx_k_start_handler), 0, 0, 1, 1}, {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, {&__pyx_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_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, {&__pyx_n_s_struct___init, __pyx_k_struct___init, sizeof(__pyx_k_struct___init), 0, 0, 1, 1}, {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1}, {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, {&__pyx_n_s_tmp, __pyx_k_tmp, sizeof(__pyx_k_tmp), 0, 0, 1, 1}, {&__pyx_n_s_tt, __pyx_k_tt, sizeof(__pyx_k_tt), 0, 0, 1, 1}, {&__pyx_n_s_types, __pyx_k_types, sizeof(__pyx_k_types), 0, 0, 1, 1}, {&__pyx_n_s_typespec, __pyx_k_typespec, sizeof(__pyx_k_typespec), 0, 0, 1, 1}, {&__pyx_kp_s_typespec_must_be_a_string_or_Non, __pyx_k_typespec_must_be_a_string_or_Non, sizeof(__pyx_k_typespec_must_be_a_string_or_Non), 0, 0, 1, 0}, {&__pyx_kp_s_unknown_OSC_data_type_c, __pyx_k_unknown_OSC_data_type_c, sizeof(__pyx_k_unknown_OSC_data_type_c), 0, 0, 1, 0}, {&__pyx_kp_s_unsupported_message_argument_typ, __pyx_k_unsupported_message_argument_typ, sizeof(__pyx_k_unsupported_message_argument_typ), 0, 0, 1, 0}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 0, 1, 1}, {&__pyx_n_s_user_data, __pyx_k_user_data, sizeof(__pyx_k_user_data), 0, 0, 1, 1}, {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1}, {&__pyx_n_s_varargs, __pyx_k_varargs, sizeof(__pyx_k_varargs), 0, 0, 1, 1}, {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, {&__pyx_n_s_weakref, __pyx_k_weakref, sizeof(__pyx_k_weakref), 0, 0, 1, 1}, {&__pyx_n_s_weakref_2, __pyx_k_weakref_2, sizeof(__pyx_k_weakref_2), 0, 0, 1, 1}, {&__pyx_n_s_weakref_method, __pyx_k_weakref_method, sizeof(__pyx_k_weakref_method), 0, 0, 1, 1}, {&__pyx_n_s_weakref_method___call, __pyx_k_weakref_method___call, sizeof(__pyx_k_weakref_method___call), 0, 0, 1, 1}, {&__pyx_n_s_weakref_method___init, __pyx_k_weakref_method___init, sizeof(__pyx_k_weakref_method___init), 0, 0, 1, 1}, {&__pyx_n_s_weakref_method_func, __pyx_k_weakref_method_func, sizeof(__pyx_k_weakref_method_func), 0, 0, 1, 1}, {&__pyx_n_s_where, __pyx_k_where, sizeof(__pyx_k_where), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 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_property = __Pyx_GetBuiltinName(__pyx_n_s_property); if (!__pyx_builtin_property) __PYX_ERR(0, 59, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 42, __pyx_L1_error) __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) __PYX_ERR(0, 198, __pyx_L1_error) __pyx_builtin_chr = __Pyx_GetBuiltinName(__pyx_n_s_chr); if (!__pyx_builtin_chr) __PYX_ERR(0, 263, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 371, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 466, __pyx_L1_error) __pyx_builtin_OverflowError = __Pyx_GetBuiltinName(__pyx_n_s_OverflowError); if (!__pyx_builtin_OverflowError) __PYX_ERR(0, 1017, __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); /* "pyliblo3/_liblo.pyx":371 * cdef _check(self): * if self._server == NULL: * raise RuntimeError("Server method called after free()") # <<<<<<<<<<<<<< * * def register_methods(self, obj=None): */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Server_method_called_after_free); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "pyliblo3/_liblo.pyx":466 * p = NULL * else: * raise TypeError("path must be a string or None") # <<<<<<<<<<<<<< * * if isinstance(typespec, (bytes, unicode)): */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_path_must_be_a_string_or_None); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 466, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "pyliblo3/_liblo.pyx":474 * t = NULL * else: * raise TypeError("typespec must be a string or None") # <<<<<<<<<<<<<< * * self._check() */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_typespec_must_be_a_string_or_Non); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "pyliblo3/_liblo.pyx":897 * size = len(arr) * if size < 1: * raise ValueError("blob is empty") # <<<<<<<<<<<<<< * # copy each element of arr to a C array * p = malloc(size) */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_blob_is_empty); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "pyliblo3/_liblo.pyx":1033 * iter(value) * except TypeError: * raise TypeError("unsupported message argument type") # <<<<<<<<<<<<<< * self._add('b', value) * */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_unsupported_message_argument_typ); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 1033, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "pyliblo3/_liblo.pyx":1074 * tt.sec, tt.frac = t * else: * raise TypeError("invalid timetag") # <<<<<<<<<<<<<< * # first argument was timetag, so continue with second * messages = messages[1:] */ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_invalid_timetag); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 1074, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb933e34, 0x7cc8780, 0x302b03a): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xb933e34, 0x7cc8780, 0x302b03a) = (func, has_varargs, numargs, user_data))" % __pyx_checksum */ __pyx_tuple__10 = PyTuple_Pack(3, __pyx_int_194199092, __pyx_int_130844544, __pyx_int_50507834); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "pyliblo3/_liblo.pyx":34 * * * def _protostr_to_int(str proto): # <<<<<<<<<<<<<< * if proto == 'UDP': * return LO_UDP */ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_proto); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 34, __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_pyliblo3__liblo_pyx, __pyx_n_s_protostr_to_int, 34, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 34, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":49 * Weak reference to a function, including support for bound methods. * """ * __slots__ = ('_func', 'obj') # <<<<<<<<<<<<<< * * def __init__(self, f): */ __pyx_tuple__15 = PyTuple_Pack(2, __pyx_n_s_func_2, __pyx_n_s_obj); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "pyliblo3/_liblo.pyx":51 * __slots__ = ('_func', 'obj') * * def __init__(self, f): # <<<<<<<<<<<<<< * if _inspect.ismethod(f): * self._func = f.__func__ */ __pyx_tuple__16 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_f); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 51, __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_pyliblo3__liblo_pyx, __pyx_n_s_init, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 51, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":59 * self.obj = None * * @property # <<<<<<<<<<<<<< * def func(self): * if self.obj: */ __pyx_tuple__18 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 59, __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__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_func_3, 59, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 59, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":66 * return self._func * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< * return self.func(*args, **kwargs) * */ __pyx_tuple__20 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_args, __pyx_n_s_kwargs); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_call, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 66, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":71 * * class struct: * def __init__(self, **kwargs): # <<<<<<<<<<<<<< * for k, v in kwargs.items(): * setattr(self, k, v) */ __pyx_tuple__22 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_kwargs, __pyx_n_s_k, __pyx_n_s_v); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_init, 71, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 71, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ __pyx_tuple__24 = 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__24)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __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(2, 1, __pyx_L1_error) /* "(tree fragment)":16 * else: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Callback__set_state(self, __pyx_state) */ __pyx_tuple__26 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(2, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(2, 16, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":143 * return tt.sec + ((tt.frac) / 4294967296.0) * * def time(): # <<<<<<<<<<<<<< * """ * Return the current time as a floating point number (seconds since January 1, 1900). */ __pyx_tuple__28 = PyTuple_Pack(1, __pyx_n_s_tt); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_time, 143, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 143, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":202 * * * def send(target, *args): # <<<<<<<<<<<<<< * """ * Send a message without requiring a server */ __pyx_tuple__30 = PyTuple_Pack(2, __pyx_n_s_target, __pyx_n_s_args); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 202, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_send, 202, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 202, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":237 * Raised when creating a liblo OSC server fails. * """ * def __init__(self, num, msg, where): # <<<<<<<<<<<<<< * self.num = num * self.msg = msg */ __pyx_tuple__32 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_num, __pyx_n_s_msg, __pyx_n_s_where); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 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_pyliblo3__liblo_pyx, __pyx_n_s_init, 237, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 237, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":241 * self.msg = msg * self.where = where * def __str__(self): # <<<<<<<<<<<<<< * s = "server error %d" % self.num * if self.where: s += " in %s" % self.where */ __pyx_tuple__34 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_s_2); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); __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__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_str, 241, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 241, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":340 * _counter = 0 * * def __init__(self, path, types, user_data=None): # <<<<<<<<<<<<<< * self.spec = struct(counter=make_method._counter, * path=path, */ __pyx_tuple__36 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_types, __pyx_n_s_user_data); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(4, 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_pyliblo3__liblo_pyx, __pyx_n_s_init, 340, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 340, __pyx_L1_error) __pyx_tuple__38 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "pyliblo3/_liblo.pyx":347 * make_method._counter += 1 * * def __call__(self, f): # <<<<<<<<<<<<<< * # we can't access the Server object here, because at the time the * # decorator is run it doesn't even exist yet, so we store the */ __pyx_codeobj__39 = (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_pyliblo3__liblo_pyx, __pyx_n_s_call, 347, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 347, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":373 * raise RuntimeError("Server method called after free()") * * def register_methods(self, obj=None): # <<<<<<<<<<<<<< * """ * Called internally during init if reg_methods is True */ __pyx_tuple__40 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_obj, __pyx_n_s_methods, __pyx_n_s_m, __pyx_n_s_spec, __pyx_n_s_e); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 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_pyliblo3__liblo_pyx, __pyx_n_s_register_methods, 373, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 373, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":397 * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) * * def get_url(self): # <<<<<<<<<<<<<< * """ * Returns the url of the server */ __pyx_tuple__42 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_tmp, __pyx_n_s_r); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__42); __Pyx_GIVEREF(__pyx_tuple__42); __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(1, 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_pyliblo3__liblo_pyx, __pyx_n_s_get_url, 397, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 397, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":410 * return _decode(r) * * def get_port(self): # <<<<<<<<<<<<<< * """ * Returns the port number of this server */ __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_get_port, 410, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 410, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":420 * return lo_server_get_port(self._server) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * Returns the protocol of this server, as an int */ __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_get_protocol, 420, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 420, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":432 * return lo_server_get_protocol(self._server) * * def fileno(self): # <<<<<<<<<<<<<< * """ * Return the file descriptor of the server socket */ __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_fileno, 432, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 432, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":442 * return lo_server_get_socket_fd(self._server) * * def add_method(self, str path, str typespec, func, user_data=None): # <<<<<<<<<<<<<< * """ * Register a callback for OSC messages with matching path and argument types. */ __pyx_tuple__47 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_typespec, __pyx_n_s_func_3, __pyx_n_s_user_data, __pyx_n_s_p, __pyx_n_s_t, __pyx_n_s_s_2, __pyx_n_s_s2, __pyx_n_s_cb); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 442, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_add_method, 442, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(0, 442, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":489 * lo_server_add_method(self._server, p, t, _msg_callback, cb) * * def del_method(self, path, typespec=None): # <<<<<<<<<<<<<< * """ * Delete a callback function */ __pyx_tuple__49 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_typespec, __pyx_n_s_p, __pyx_n_s_t, __pyx_n_s_s_2, __pyx_n_s_s2); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__49); __Pyx_GIVEREF(__pyx_tuple__49); __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__49, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_del_method, 489, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(0, 489, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":523 * lo_server_del_method(self._server, p, t) * * def add_bundle_handlers(self, start_handler, end_handler, user_data=None): # <<<<<<<<<<<<<< * """ * Add bundle notification handlers. */ __pyx_tuple__51 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_start_handler, __pyx_n_s_end_handler, __pyx_n_s_user_data, __pyx_n_s_cb_data); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 5, 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_pyliblo3__liblo_pyx, __pyx_n_s_add_bundle_handlers, 523, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(0, 523, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":543 * _bundle_end_callback, cb_data) * * def send(self, target, *args): # <<<<<<<<<<<<<< * """ * Send a message or bundle from this server to the the given target. */ __pyx_tuple__53 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_target, __pyx_n_s_args); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 543, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__53, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_send, 543, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(0, 543, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_codeobj__55 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__55)) __PYX_ERR(2, 1, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(2, 3, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":631 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ __pyx_codeobj__57 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_free, 631, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__57)) __PYX_ERR(0, 631, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":641 * self._server = NULL * * def recv(self, timeout=None): # <<<<<<<<<<<<<< * """ * Receive and dispatch one OSC message. */ __pyx_tuple__58 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_timeout, __pyx_n_s_t, __pyx_n_s_r); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); __pyx_codeobj__59 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 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_pyliblo3__liblo_pyx, __pyx_n_s_recv, 641, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__59)) __PYX_ERR(0, 641, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(2, 1, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(2, 3, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":723 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_free, 723, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(0, 723, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":736 * self._server = NULL * * def start(self): # <<<<<<<<<<<<<< * """ * Start the server thread. */ __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__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_start, 736, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__63)) __PYX_ERR(0, 736, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":745 * lo_server_thread_start(self._server_thread) * * def stop(self): # <<<<<<<<<<<<<< * """ * Stop the server thread. */ __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_stop, 745, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(0, 745, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_codeobj__65 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__65)) __PYX_ERR(2, 1, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" */ __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(2, 3, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":761 * Raised when trying to create an invalid `Address` object. * """ * def __init__(self, msg): # <<<<<<<<<<<<<< * self.msg = msg * def __str__(self): */ __pyx_tuple__67 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 761, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_init, 761, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(0, 761, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":763 * def __init__(self, msg): * self.msg = msg * def __str__(self): # <<<<<<<<<<<<<< * return "address error: %s" % self.msg * */ __pyx_codeobj__69 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_str, 763, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__69)) __PYX_ERR(0, 763, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":819 * lo_address_free(self._address) * * def get_url(self): # <<<<<<<<<<<<<< * """This Address as a liblo URL""" * cdef char *tmp = lo_address_get_url(self._address) */ __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(1, 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_pyliblo3__liblo_pyx, __pyx_n_s_get_url, 819, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(0, 819, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":826 * return _decode(r) * * def get_hostname(self): # <<<<<<<<<<<<<< * """The hostname of this Address""" * return _decode(lo_address_get_hostname(self._address)) */ __pyx_codeobj__71 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_get_hostname, 826, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__71)) __PYX_ERR(0, 826, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":830 * return _decode(lo_address_get_hostname(self._address)) * * def get_port(self): # <<<<<<<<<<<<<< * """The port number of this Address""" * cdef bytes s = lo_address_get_port(self._address) */ __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_get_port, 830, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(0, 830, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":838 * return _decode(s) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * The protocol used as an int */ __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 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_pyliblo3__liblo_pyx, __pyx_n_s_get_protocol, 838, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) __PYX_ERR(0, 838, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(2, 1, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" */ __pyx_codeobj__75 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__75)) __PYX_ERR(2, 3, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(2, 1, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" */ __pyx_codeobj__77 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__77)) __PYX_ERR(2, 3, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":940 * lo_message_free(self._message) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Append the given arguments to this message */ __pyx_tuple__78 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_args, __pyx_n_s_arg); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 940, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__78); __Pyx_GIVEREF(__pyx_tuple__78); __pyx_codeobj__79 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__78, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_add, 940, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__79)) __PYX_ERR(0, 940, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) __PYX_ERR(2, 1, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" */ __pyx_codeobj__81 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__81)) __PYX_ERR(2, 3, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":1085 * lo_bundle_free(self._bundle) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Add one or more messages to this bundle */ __pyx_tuple__82 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_args, __pyx_n_s_messages, __pyx_n_s_m, __pyx_n_s_message); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 1085, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__82); __Pyx_GIVEREF(__pyx_tuple__82); __pyx_codeobj__83 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__82, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pyliblo3__liblo_pyx, __pyx_n_s_add, 1085, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__83)) __PYX_ERR(0, 1085, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) __PYX_ERR(2, 1, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" */ __pyx_codeobj__85 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 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_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__85)) __PYX_ERR(2, 3, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_Callback(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__86 = 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__86)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__86); __Pyx_GIVEREF(__pyx_tuple__86); __pyx_codeobj__87 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__86, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Callback, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__87)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } /* #### Code section: init_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { __pyx_umethod_PyBytes_Type_isdigit.type = (PyObject*)&PyBytes_Type; __pyx_umethod_PyBytes_Type_isdigit.method_name = &__pyx_n_s_isdigit; if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_50507834 = PyInt_FromLong(50507834L); if (unlikely(!__pyx_int_50507834)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_130844544 = PyInt_FromLong(130844544L); if (unlikely(!__pyx_int_130844544)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_194199092 = PyInt_FromLong(194199092L); if (unlikely(!__pyx_int_194199092)) __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 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 CYTHON_USE_TYPE_SPECS __pyx_ptype_8pyliblo3_6_liblo_Callback = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo_Callback_spec, NULL); if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo_Callback)) __PYX_ERR(0, 76, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo_Callback_spec, __pyx_ptype_8pyliblo3_6_liblo_Callback) < 0) __PYX_ERR(0, 76, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo_Callback = &__pyx_type_8pyliblo3_6_liblo_Callback; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo_Callback) < 0) __PYX_ERR(0, 76, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo_Callback->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo_Callback->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo_Callback->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo_Callback->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Callback, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Callback) < 0) __PYX_ERR(0, 76, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Callback) < 0) __PYX_ERR(0, 76, __pyx_L1_error) #endif __pyx_vtabptr_8pyliblo3_6_liblo__ServerBase = &__pyx_vtable_8pyliblo3_6_liblo__ServerBase; __pyx_vtable_8pyliblo3_6_liblo__ServerBase._check = (PyObject *(*)(struct __pyx_obj_8pyliblo3_6_liblo__ServerBase *))__pyx_f_8pyliblo3_6_liblo_11_ServerBase__check; #if CYTHON_USE_TYPE_SPECS __pyx_ptype_8pyliblo3_6_liblo__ServerBase = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo__ServerBase_spec, NULL); if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo__ServerBase)) __PYX_ERR(0, 359, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo__ServerBase_spec, __pyx_ptype_8pyliblo3_6_liblo__ServerBase) < 0) __PYX_ERR(0, 359, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo__ServerBase = &__pyx_type_8pyliblo3_6_liblo__ServerBase; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo__ServerBase) < 0) __PYX_ERR(0, 359, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo__ServerBase->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo__ServerBase->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo__ServerBase->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo__ServerBase->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_vtabptr_8pyliblo3_6_liblo__ServerBase) < 0) __PYX_ERR(0, 359, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_ptype_8pyliblo3_6_liblo__ServerBase) < 0) __PYX_ERR(0, 359, __pyx_L1_error) #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ServerBase, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo__ServerBase) < 0) __PYX_ERR(0, 359, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo__ServerBase) < 0) __PYX_ERR(0, 359, __pyx_L1_error) #endif #if CYTHON_USE_TYPE_SPECS __pyx_ptype_8pyliblo3_6_liblo_Address = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo_Address_spec, NULL); if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo_Address)) __PYX_ERR(0, 767, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo_Address_spec, __pyx_ptype_8pyliblo3_6_liblo_Address) < 0) __PYX_ERR(0, 767, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo_Address = &__pyx_type_8pyliblo3_6_liblo_Address; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo_Address) < 0) __PYX_ERR(0, 767, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo_Address->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo_Address->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo_Address->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo_Address->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Address, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Address) < 0) __PYX_ERR(0, 767, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Address) < 0) __PYX_ERR(0, 767, __pyx_L1_error) #endif __pyx_vtabptr_8pyliblo3_6_liblo_Message = &__pyx_vtable_8pyliblo3_6_liblo_Message; __pyx_vtable_8pyliblo3_6_liblo_Message._add = (PyObject *(*)(struct __pyx_obj_8pyliblo3_6_liblo_Message *, PyObject *, PyObject *))__pyx_f_8pyliblo3_6_liblo_7Message__add; __pyx_vtable_8pyliblo3_6_liblo_Message._add_auto = (PyObject *(*)(struct __pyx_obj_8pyliblo3_6_liblo_Message *, PyObject *))__pyx_f_8pyliblo3_6_liblo_7Message__add_auto; #if CYTHON_USE_TYPE_SPECS __pyx_ptype_8pyliblo3_6_liblo_Message = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo_Message_spec, NULL); if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo_Message)) __PYX_ERR(0, 917, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo_Message_spec, __pyx_ptype_8pyliblo3_6_liblo_Message) < 0) __PYX_ERR(0, 917, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo_Message = &__pyx_type_8pyliblo3_6_liblo_Message; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo_Message) < 0) __PYX_ERR(0, 917, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo_Message->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo_Message->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo_Message->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo_Message->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_ptype_8pyliblo3_6_liblo_Message, __pyx_vtabptr_8pyliblo3_6_liblo_Message) < 0) __PYX_ERR(0, 917, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_ptype_8pyliblo3_6_liblo_Message) < 0) __PYX_ERR(0, 917, __pyx_L1_error) #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Message, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Message) < 0) __PYX_ERR(0, 917, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Message) < 0) __PYX_ERR(0, 917, __pyx_L1_error) #endif #if CYTHON_USE_TYPE_SPECS __pyx_ptype_8pyliblo3_6_liblo_Bundle = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo_Bundle_spec, NULL); if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo_Bundle)) __PYX_ERR(0, 1041, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo_Bundle_spec, __pyx_ptype_8pyliblo3_6_liblo_Bundle) < 0) __PYX_ERR(0, 1041, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo_Bundle = &__pyx_type_8pyliblo3_6_liblo_Bundle; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo_Bundle) < 0) __PYX_ERR(0, 1041, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo_Bundle->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo_Bundle->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo_Bundle->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo_Bundle->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Bundle, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Bundle) < 0) __PYX_ERR(0, 1041, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Bundle) < 0) __PYX_ERR(0, 1041, __pyx_L1_error) #endif __pyx_vtabptr_8pyliblo3_6_liblo_Server = &__pyx_vtable_8pyliblo3_6_liblo_Server; __pyx_vtable_8pyliblo3_6_liblo_Server.__pyx_base = *__pyx_vtabptr_8pyliblo3_6_liblo__ServerBase; #if CYTHON_USE_TYPE_SPECS __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_8pyliblo3_6_liblo_Server = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo_Server_spec, __pyx_t_1); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo_Server)) __PYX_ERR(0, 589, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo_Server_spec, __pyx_ptype_8pyliblo3_6_liblo_Server) < 0) __PYX_ERR(0, 589, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo_Server = &__pyx_type_8pyliblo3_6_liblo_Server; #endif #if !CYTHON_COMPILING_IN_LIMITED_API __pyx_ptype_8pyliblo3_6_liblo_Server->tp_base = __pyx_ptype_8pyliblo3_6_liblo__ServerBase; #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo_Server) < 0) __PYX_ERR(0, 589, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo_Server->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo_Server->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo_Server->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo_Server->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_ptype_8pyliblo3_6_liblo_Server, __pyx_vtabptr_8pyliblo3_6_liblo_Server) < 0) __PYX_ERR(0, 589, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_ptype_8pyliblo3_6_liblo_Server) < 0) __PYX_ERR(0, 589, __pyx_L1_error) #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Server, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Server) < 0) __PYX_ERR(0, 589, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo_Server) < 0) __PYX_ERR(0, 589, __pyx_L1_error) #endif __pyx_vtabptr_8pyliblo3_6_liblo_ServerThread = &__pyx_vtable_8pyliblo3_6_liblo_ServerThread; __pyx_vtable_8pyliblo3_6_liblo_ServerThread.__pyx_base = *__pyx_vtabptr_8pyliblo3_6_liblo__ServerBase; #if CYTHON_USE_TYPE_SPECS __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_8pyliblo3_6_liblo_ServerThread = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo_ServerThread_spec, __pyx_t_1); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo_ServerThread)) __PYX_ERR(0, 668, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo_ServerThread_spec, __pyx_ptype_8pyliblo3_6_liblo_ServerThread) < 0) __PYX_ERR(0, 668, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo_ServerThread = &__pyx_type_8pyliblo3_6_liblo_ServerThread; #endif #if !CYTHON_COMPILING_IN_LIMITED_API __pyx_ptype_8pyliblo3_6_liblo_ServerThread->tp_base = __pyx_ptype_8pyliblo3_6_liblo__ServerBase; #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo_ServerThread) < 0) __PYX_ERR(0, 668, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo_ServerThread->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo_ServerThread->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo_ServerThread->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo_ServerThread->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_ptype_8pyliblo3_6_liblo_ServerThread, __pyx_vtabptr_8pyliblo3_6_liblo_ServerThread) < 0) __PYX_ERR(0, 668, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_ptype_8pyliblo3_6_liblo_ServerThread) < 0) __PYX_ERR(0, 668, __pyx_L1_error) #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ServerThread, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo_ServerThread) < 0) __PYX_ERR(0, 668, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo_ServerThread) < 0) __PYX_ERR(0, 668, __pyx_L1_error) #endif #if CYTHON_USE_TYPE_SPECS __pyx_ptype_8pyliblo3_6_liblo__Blob = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_8pyliblo3_6_liblo__Blob_spec, NULL); if (unlikely(!__pyx_ptype_8pyliblo3_6_liblo__Blob)) __PYX_ERR(0, 888, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_8pyliblo3_6_liblo__Blob_spec, __pyx_ptype_8pyliblo3_6_liblo__Blob) < 0) __PYX_ERR(0, 888, __pyx_L1_error) #else __pyx_ptype_8pyliblo3_6_liblo__Blob = &__pyx_type_8pyliblo3_6_liblo__Blob; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_ptype_8pyliblo3_6_liblo__Blob) < 0) __PYX_ERR(0, 888, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_ptype_8pyliblo3_6_liblo__Blob->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_8pyliblo3_6_liblo__Blob->tp_dictoffset && __pyx_ptype_8pyliblo3_6_liblo__Blob->tp_getattro == PyObject_GenericGetAttr)) { __pyx_ptype_8pyliblo3_6_liblo__Blob->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Blob, (PyObject *) __pyx_ptype_8pyliblo3_6_liblo__Blob) < 0) __PYX_ERR(0, 888, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_8pyliblo3_6_liblo__Blob) < 0) __PYX_ERR(0, 888, __pyx_L1_error) #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), #elif CYTHON_COMPILING_IN_LIMITED_API sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), #else sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType_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(4, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType_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(5, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__liblo(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__liblo}, {0, NULL} }; #endif #ifdef __cplusplus namespace { struct PyModuleDef __pyx_moduledef = #else static struct PyModuleDef __pyx_moduledef = #endif { PyModuleDef_HEAD_INIT, "_liblo", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #elif CYTHON_USE_MODULE_STATE sizeof(__pyx_mstate), /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif #if CYTHON_USE_MODULE_STATE __pyx_m_traverse, /* m_traverse */ __pyx_m_clear, /* m_clear */ NULL /* m_free */ #else NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ #endif }; #ifdef __cplusplus } /* anonymous namespace */ #endif #endif #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init_liblo(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init_liblo(void) #else __Pyx_PyMODINIT_FUNC PyInit__liblo(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__liblo(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__liblo(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; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = 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 '_liblo' 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("_liblo", __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 "_liblo" 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__liblo(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_pyliblo3___liblo) { 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, "pyliblo3._liblo")) { if (unlikely((PyDict_SetItemString(modules, "pyliblo3._liblo", __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(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "pyliblo3/_liblo.pyx":17 * # * * __version__ = '0.16.1' # <<<<<<<<<<<<<< * * */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_kp_s_0_16_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":30 * from _liblo cimport * * * import inspect as _inspect # <<<<<<<<<<<<<< * import weakref as _weakref * */ __pyx_t_2 = __Pyx_patch_inspect(__Pyx_ImportDottedModule(__pyx_n_s_inspect_2, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_inspect, __pyx_t_2) < 0) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":31 * * import inspect as _inspect * import weakref as _weakref # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_weakref_2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_weakref, __pyx_t_2) < 0) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":34 * * * def _protostr_to_int(str proto): # <<<<<<<<<<<<<< * if proto == 'UDP': * return LO_UDP */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_1_protostr_to_int, 0, __pyx_n_s_protostr_to_int, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_protostr_to_int, __pyx_t_2) < 0) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":45 * * * class _weakref_method: # <<<<<<<<<<<<<< * """ * Weak reference to a function, including support for bound methods. */ __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_weakref_method, __pyx_n_s_weakref_method, (PyObject *) NULL, __pyx_n_s_pyliblo3__liblo, __pyx_kp_s_Weak_reference_to_a_function_in); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pyliblo3/_liblo.pyx":49 * Weak reference to a function, including support for bound methods. * """ * __slots__ = ('_func', 'obj') # <<<<<<<<<<<<<< * * def __init__(self, f): */ if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_slots, __pyx_tuple__15) < 0) __PYX_ERR(0, 49, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":51 * __slots__ = ('_func', 'obj') * * def __init__(self, f): # <<<<<<<<<<<<<< * if _inspect.ismethod(f): * self._func = f.__func__ */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_15_weakref_method_1__init__, 0, __pyx_n_s_weakref_method___init, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_3) < 0) __PYX_ERR(0, 51, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":59 * self.obj = None * * @property # <<<<<<<<<<<<<< * def func(self): * if self.obj: */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_15_weakref_method_3func, 0, __pyx_n_s_weakref_method_func, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_func_3, __pyx_t_4) < 0) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":66 * return self._func * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< * return self.func(*args, **kwargs) * */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_15_weakref_method_5__call__, 0, __pyx_n_s_weakref_method___call, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_call, __pyx_t_4) < 0) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":45 * * * class _weakref_method: # <<<<<<<<<<<<<< * """ * Weak reference to a function, including support for bound methods. */ __pyx_t_4 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_n_s_weakref_method, __pyx_empty_tuple, __pyx_t_2, NULL, 0, 0); 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_weakref_method, __pyx_t_4) < 0) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":70 * * * class struct: # <<<<<<<<<<<<<< * def __init__(self, **kwargs): * for k, v in kwargs.items(): */ __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_struct, __pyx_n_s_struct, (PyObject *) NULL, __pyx_n_s_pyliblo3__liblo, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pyliblo3/_liblo.pyx":71 * * class struct: * def __init__(self, **kwargs): # <<<<<<<<<<<<<< * for k, v in kwargs.items(): * setattr(self, k, v) */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6struct_1__init__, 0, __pyx_n_s_struct___init, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_4) < 0) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":70 * * * class struct: # <<<<<<<<<<<<<< * def __init__(self, **kwargs): * for k, v in kwargs.items(): */ __pyx_t_4 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_n_s_struct, __pyx_empty_tuple, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_struct, __pyx_t_4) < 0) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_8Callback_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Callback___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Callback, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Callback); /* "(tree fragment)":16 * else: * return __pyx_unpickle_Callback, (type(self), 0xb933e34, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Callback__set_state(self, __pyx_state) */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_8Callback_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Callback___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Callback, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(2, 16, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Callback); /* "pyliblo3/_liblo.pyx":123 * * # liblo protocol constants * UDP = LO_UDP # <<<<<<<<<<<<<< * TCP = LO_TCP * UNIX = LO_UNIX */ __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LO_UDP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_UDP, __pyx_t_2) < 0) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":124 * # liblo protocol constants * UDP = LO_UDP * TCP = LO_TCP # <<<<<<<<<<<<<< * UNIX = LO_UNIX * */ __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LO_TCP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP, __pyx_t_2) < 0) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":125 * UDP = LO_UDP * TCP = LO_TCP * UNIX = LO_UNIX # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LO_UNIX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_UNIX, __pyx_t_2) < 0) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":143 * return tt.sec + ((tt.frac) / 4294967296.0) * * def time(): # <<<<<<<<<<<<<< * """ * Return the current time as a floating point number (seconds since January 1, 1900). */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_3time, 0, __pyx_n_s_time, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_2) < 0) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":202 * * * def send(target, *args): # <<<<<<<<<<<<<< * """ * Send a message without requiring a server */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_5send, 0, __pyx_n_s_send, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_send, __pyx_t_2) < 0) __PYX_ERR(0, 202, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":233 * ################################################################################ * * class ServerError(Exception): # <<<<<<<<<<<<<< * """ * Raised when creating a liblo OSC server fails. */ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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, 233, __pyx_L1_error); __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_4, __pyx_n_s_ServerError, __pyx_n_s_ServerError, (PyObject *) NULL, __pyx_n_s_pyliblo3__liblo, __pyx_kp_s_Raised_when_creating_a_liblo_OS); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 233, __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, 233, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":237 * Raised when creating a liblo OSC server fails. * """ * def __init__(self, num, msg, where): # <<<<<<<<<<<<<< * self.num = num * self.msg = msg */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11ServerError_1__init__, 0, __pyx_n_s_ServerError___init, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_init, __pyx_t_2) < 0) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":241 * self.msg = msg * self.where = where * def __str__(self): # <<<<<<<<<<<<<< * s = "server error %d" % self.num * if self.where: s += " in %s" % self.where */ __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11ServerError_3__str__, 0, __pyx_n_s_ServerError___str, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_n_s_str, __pyx_t_2) < 0) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyliblo3/_liblo.pyx":233 * ################################################################################ * * class ServerError(Exception): # <<<<<<<<<<<<<< * """ * Raised when creating a liblo OSC server fails. */ __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_ServerError, __pyx_t_4, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ServerError, __pyx_t_2) < 0) __PYX_ERR(0, 233, __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; /* "pyliblo3/_liblo.pyx":323 * # decorator to register callbacks * * class make_method: # <<<<<<<<<<<<<< * """ * A decorator that serves as a more convenient alternative to [Server.add_method](#add_method). */ __pyx_t_4 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_make_method, __pyx_n_s_make_method, (PyObject *) NULL, __pyx_n_s_pyliblo3__liblo, __pyx_kp_s_A_decorator_that_serves_as_a_mo); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "pyliblo3/_liblo.pyx":338 * # counter to keep track of the order in which the callback functions where * # defined * _counter = 0 # <<<<<<<<<<<<<< * * def __init__(self, path, types, user_data=None): */ if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_counter_2, __pyx_int_0) < 0) __PYX_ERR(0, 338, __pyx_L1_error) /* "pyliblo3/_liblo.pyx":340 * _counter = 0 * * def __init__(self, path, types, user_data=None): # <<<<<<<<<<<<<< * self.spec = struct(counter=make_method._counter, * path=path, */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11make_method_1__init__, 0, __pyx_n_s_make_method___init, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__38); if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_init, __pyx_t_3) < 0) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":347 * make_method._counter += 1 * * def __call__(self, f): # <<<<<<<<<<<<<< * # we can't access the Server object here, because at the time the * # decorator is run it doesn't even exist yet, so we store the */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11make_method_3__call__, 0, __pyx_n_s_make_method___call, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_call, __pyx_t_3) < 0) __PYX_ERR(0, 347, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":323 * # decorator to register callbacks * * class make_method: # <<<<<<<<<<<<<< * """ * A decorator that serves as a more convenient alternative to [Server.add_method](#add_method). */ __pyx_t_3 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_n_s_make_method, __pyx_empty_tuple, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_method, __pyx_t_3) < 0) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":373 * raise RuntimeError("Server method called after free()") * * def register_methods(self, obj=None): # <<<<<<<<<<<<<< * """ * Called internally during init if reg_methods is True */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_3register_methods, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_register_methods, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__38); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_register_methods, __pyx_t_4) < 0) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":397 * self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) * * def get_url(self): # <<<<<<<<<<<<<< * """ * Returns the url of the server */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_5get_url, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_get_url, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_get_url, __pyx_t_4) < 0) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":410 * return _decode(r) * * def get_port(self): # <<<<<<<<<<<<<< * """ * Returns the port number of this server */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_7get_port, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_get_port, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_get_port, __pyx_t_4) < 0) __PYX_ERR(0, 410, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":420 * return lo_server_get_port(self._server) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * Returns the protocol of this server, as an int */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_9get_protocol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_get_protocol, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_get_protocol, __pyx_t_4) < 0) __PYX_ERR(0, 420, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":432 * return lo_server_get_protocol(self._server) * * def fileno(self): # <<<<<<<<<<<<<< * """ * Return the file descriptor of the server socket */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_11fileno, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_fileno, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_fileno, __pyx_t_4) < 0) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":442 * return lo_server_get_socket_fd(self._server) * * def add_method(self, str path, str typespec, func, user_data=None): # <<<<<<<<<<<<<< * """ * Register a callback for OSC messages with matching path and argument types. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_13add_method, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_add_method, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__48)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 442, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__38); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_add_method, __pyx_t_4) < 0) __PYX_ERR(0, 442, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":489 * lo_server_add_method(self._server, p, t, _msg_callback, cb) * * def del_method(self, path, typespec=None): # <<<<<<<<<<<<<< * """ * Delete a callback function */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_15del_method, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_del_method, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__50)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__38); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_del_method, __pyx_t_4) < 0) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":523 * lo_server_del_method(self._server, p, t) * * def add_bundle_handlers(self, start_handler, end_handler, user_data=None): # <<<<<<<<<<<<<< * """ * Add bundle notification handlers. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_17add_bundle_handlers, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_add_bundle_handlers, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__52)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__38); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_add_bundle_handlers, __pyx_t_4) < 0) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "pyliblo3/_liblo.pyx":543 * _bundle_end_callback, cb_data) * * def send(self, target, *args): # <<<<<<<<<<<<<< * """ * Send a message or bundle from this server to the the given target. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_19send, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase_send, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__54)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 543, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo__ServerBase, __pyx_n_s_send, __pyx_t_4) < 0) __PYX_ERR(0, 543, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo__ServerBase); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_21__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__55)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_11_ServerBase_23__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerBase___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__56)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":608 * * """ * def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): # <<<<<<<<<<<<<< * cdef char *cs * */ __pyx_t_4 = __Pyx_PyInt_From___pyx_anon_enum(LO_DEFAULT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_k__4 = __pyx_t_4; __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":631 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6Server_5free, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Server_free, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__57)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Server, __pyx_n_s_free, __pyx_t_4) < 0) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Server); /* "pyliblo3/_liblo.pyx":641 * self._server = NULL * * def recv(self, timeout=None): # <<<<<<<<<<<<<< * """ * Receive and dispatch one OSC message. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6Server_7recv, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Server_recv, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__59)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__38); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Server, __pyx_n_s_recv, __pyx_t_4) < 0) __PYX_ERR(0, 641, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Server); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6Server_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Server___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__60)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server cannot be converted to a Python object for pickling" */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6Server_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Server___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__61)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":699 * cdef lo_server_thread _server_thread * * def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): # <<<<<<<<<<<<<< * cdef char *cs * */ __pyx_t_4 = __Pyx_PyInt_From___pyx_anon_enum(LO_DEFAULT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_k__5 = __pyx_t_4; __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":723 * self.free() * * def free(self): # <<<<<<<<<<<<<< * """ * Free the underlying server object and close its port. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_12ServerThread_5free, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerThread_free, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__62)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 723, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_ServerThread, __pyx_n_s_free, __pyx_t_4) < 0) __PYX_ERR(0, 723, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_ServerThread); /* "pyliblo3/_liblo.pyx":736 * self._server = NULL * * def start(self): # <<<<<<<<<<<<<< * """ * Start the server thread. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_12ServerThread_7start, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerThread_start, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__63)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_ServerThread, __pyx_n_s_start, __pyx_t_4) < 0) __PYX_ERR(0, 736, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_ServerThread); /* "pyliblo3/_liblo.pyx":745 * lo_server_thread_start(self._server_thread) * * def stop(self): # <<<<<<<<<<<<<< * """ * Stop the server thread. */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_12ServerThread_9stop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerThread_stop, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__64)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_ServerThread, __pyx_n_s_stop, __pyx_t_4) < 0) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_ServerThread); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_12ServerThread_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerThread___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__65)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._server,self._server_thread cannot be converted to a Python object for pickling" */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_12ServerThread_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ServerThread___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__66)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":757 * ################################################################################ * * class AddressError(Exception): # <<<<<<<<<<<<<< * """ * Raised when trying to create an invalid `Address` object. */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); __Pyx_GIVEREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])))) __PYX_ERR(0, 757, __pyx_L1_error); __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_AddressError, __pyx_n_s_AddressError, (PyObject *) NULL, __pyx_n_s_pyliblo3__liblo, __pyx_kp_s_Raised_when_trying_to_create_an); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_3 != __pyx_t_4) { if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 757, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":761 * Raised when trying to create an invalid `Address` object. * """ * def __init__(self, msg): # <<<<<<<<<<<<<< * self.msg = msg * def __str__(self): */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_12AddressError_1__init__, 0, __pyx_n_s_AddressError___init, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__68)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_4) < 0) __PYX_ERR(0, 761, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":763 * def __init__(self, msg): * self.msg = msg * def __str__(self): # <<<<<<<<<<<<<< * return "address error: %s" % self.msg * */ __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_12AddressError_3__str__, 0, __pyx_n_s_AddressError___str, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__69)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_str, __pyx_t_4) < 0) __PYX_ERR(0, 763, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyliblo3/_liblo.pyx":757 * ################################################################################ * * class AddressError(Exception): # <<<<<<<<<<<<<< * """ * Raised when trying to create an invalid `Address` object. */ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_AddressError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AddressError, __pyx_t_4) < 0) __PYX_ERR(0, 757, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __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; /* "pyliblo3/_liblo.pyx":793 * cdef lo_address _address * * def __init__(self, addr, addr2=None, proto=LO_UDP): # <<<<<<<<<<<<<< * if isinstance(proto, str): * proto = _protostr_to_int(proto) */ __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LO_UDP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_k__6 = __pyx_t_3; __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":819 * lo_address_free(self._address) * * def get_url(self): # <<<<<<<<<<<<<< * """This Address as a liblo URL""" * cdef char *tmp = lo_address_get_url(self._address) */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Address_5get_url, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address_get_url, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__70)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Address, __pyx_n_s_get_url, __pyx_t_3) < 0) __PYX_ERR(0, 819, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Address); /* "pyliblo3/_liblo.pyx":826 * return _decode(r) * * def get_hostname(self): # <<<<<<<<<<<<<< * """The hostname of this Address""" * return _decode(lo_address_get_hostname(self._address)) */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Address_7get_hostname, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address_get_hostname, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__71)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Address, __pyx_n_s_get_hostname, __pyx_t_3) < 0) __PYX_ERR(0, 826, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Address); /* "pyliblo3/_liblo.pyx":830 * return _decode(lo_address_get_hostname(self._address)) * * def get_port(self): # <<<<<<<<<<<<<< * """The port number of this Address""" * cdef bytes s = lo_address_get_port(self._address) */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Address_9get_port, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address_get_port, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__72)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Address, __pyx_n_s_get_port, __pyx_t_3) < 0) __PYX_ERR(0, 830, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Address); /* "pyliblo3/_liblo.pyx":838 * return _decode(s) * * def get_protocol(self): # <<<<<<<<<<<<<< * """ * The protocol used as an int */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Address_11get_protocol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address_get_protocol, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__73)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 838, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Address, __pyx_n_s_get_protocol, __pyx_t_3) < 0) __PYX_ERR(0, 838, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Address); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Address_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__74)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._address cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._address cannot be converted to a Python object for pickling" */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Address_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Address___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__75)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_5_Blob_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Blob___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__76)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._blob cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._blob cannot be converted to a Python object for pickling" */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_5_Blob_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Blob___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__77)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":940 * lo_message_free(self._message) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Append the given arguments to this message */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Message_5add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Message_add, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__79)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Message, __pyx_n_s_add, __pyx_t_3) < 0) __PYX_ERR(0, 940, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Message); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Message_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Message___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__80)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._message cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._message cannot be converted to a Python object for pickling" */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7Message_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Message___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__81)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":1085 * lo_bundle_free(self._bundle) * * def add(self, *args): # <<<<<<<<<<<<<< * """ * Add one or more messages to this bundle */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6Bundle_5add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Bundle_add, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__83)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1085, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_8pyliblo3_6_liblo_Bundle, __pyx_n_s_add, __pyx_t_3) < 0) __PYX_ERR(0, 1085, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_8pyliblo3_6_liblo_Bundle); /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6Bundle_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Bundle___reduce_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__84)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError, "self._bundle cannot be converted to a Python object for pickling" */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_6Bundle_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Bundle___setstate_cython, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__85)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 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(2, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":1 * def __pyx_unpickle_Callback(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_8pyliblo3_6_liblo_7__pyx_unpickle_Callback, 0, __pyx_n_s_pyx_unpickle_Callback, NULL, __pyx_n_s_pyliblo3__liblo, __pyx_d, ((PyObject *)__pyx_codeobj__87)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Callback, __pyx_t_3) < 0) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyliblo3/_liblo.pyx":1 * # cython: embedsignature=True # <<<<<<<<<<<<<< * # * # pyliblo3 - Python bindings for the lublo OSC library, based on pyliblo */ __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_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); if (__pyx_m) { if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init pyliblo3._liblo", __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 pyliblo3._liblo"); } __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; } /* JoinPyUnicode */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char) { #if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *result_uval; int result_ukind, kind_shift; Py_ssize_t i, char_pos; void *result_udata; CYTHON_MAYBE_UNUSED_VAR(max_char); #if CYTHON_PEP393_ENABLED result_uval = PyUnicode_New(result_ulength, max_char); if (unlikely(!result_uval)) return NULL; result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; result_udata = PyUnicode_DATA(result_uval); #else result_uval = PyUnicode_FromUnicode(NULL, result_ulength); if (unlikely(!result_uval)) return NULL; result_ukind = sizeof(Py_UNICODE); kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; result_udata = PyUnicode_AS_UNICODE(result_uval); #endif assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); char_pos = 0; for (i=0; i < value_count; i++) { int ukind; Py_ssize_t ulength; void *udata; PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); if (unlikely(__Pyx_PyUnicode_READY(uval))) goto bad; ulength = __Pyx_PyUnicode_GET_LENGTH(uval); if (unlikely(!ulength)) continue; if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) goto overflow; ukind = __Pyx_PyUnicode_KIND(uval); udata = __Pyx_PyUnicode_DATA(uval); if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); } else { #if PY_VERSION_HEX >= 0x030d0000 if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); #else Py_ssize_t j; for (j=0; j < ulength; j++) { Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); } #endif } char_pos += ulength; } return result_uval; overflow: PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); bad: Py_DECREF(result_uval); return NULL; #else CYTHON_UNUSED_VAR(max_char); CYTHON_UNUSED_VAR(result_ulength); CYTHON_UNUSED_VAR(value_count); return PyUnicode_Join(__pyx_empty_unicode, value_tuple); #endif } /* 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); } /* 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 /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #elif CYTHON_COMPILING_IN_LIMITED_API if (unlikely(!__pyx_m)) { return NULL; } result = PyObject_GetAttr(__pyx_m, name); if (likely(result)) { return result; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectSetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #endif /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { PyObject* exc_type; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign exc_type = __Pyx_PyErr_CurrentExceptionType(); if (unlikely(exc_type)) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) return -1; __Pyx_PyErr_Clear(); return 0; } return 0; } /* PyObjectCallNoArg */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { PyObject *arg[2] = {NULL, NULL}; return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP __Pyx_TypeName type_name; PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) #elif PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (likely(descr != NULL)) { *method = descr; return 0; } type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", type_name, name); #else "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", type_name, PyString_AS_STRING(name)); #endif __Pyx_DECREF_TypeName(type_name); return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_CallOneArg(method, obj); Py_DECREF(method); return result; } if (unlikely(!method)) goto bad; result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } return __Pyx_IterFinish(); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else if (PyTuple_GET_SIZE(t) < index) { __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { __Pyx_RaiseTooManyValuesError(index); } } /* UnpackTuple2 */ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_COMPILING_IN_PYPY value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_COMPILING_IN_PYPY bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = __Pyx_PyObject_GetIterNextFunc(iter); value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ #if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 #include #endif static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #elif PY_MAJOR_VERSION >= 3 static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* PyIntBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { CYTHON_MAYBE_UNUSED_VAR(intval); CYTHON_MAYBE_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long x; long a = PyInt_AS_LONG(op1); x = (long)((unsigned long)a - (unsigned long)b); if (likely((x^a) >= 0 || (x^~b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_subtract(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif if (unlikely(__Pyx_PyLong_IsZero(op1))) { return PyLong_FromLong(-intval); } if (likely(__Pyx_PyLong_IsCompact(op1))) { a = __Pyx_PyLong_CompactValue(op1); } else { const digit* digits = __Pyx_PyLong_Digits(op1); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1); switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); } } x = a - b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla - llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; #if CYTHON_COMPILING_IN_LIMITED_API double a = __pyx_PyFloat_AsDouble(op1); #else double a = PyFloat_AS_DOUBLE(op1); #endif double result; PyFPE_START_PROTECT("subtract", return NULL) result = ((double)a) - (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } #endif /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kw, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) goto invalid_keyword; return 1; #else if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { Py_ssize_t kwsize; #if CYTHON_ASSUME_SAFE_MACROS kwsize = PyTuple_GET_SIZE(kw); #else kwsize = PyTuple_Size(kw); if (kwsize < 0) return 0; #endif if (unlikely(kwsize == 0)) return 1; if (!kw_allowed) { #if CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kw, 0); #else key = PyTuple_GetItem(kw, pos); if (!key) return 0; #endif goto invalid_keyword; } #if PY_VERSION_HEX < 0x03090000 for (pos = 0; pos < kwsize; pos++) { #if CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kw, pos); #else key = PyTuple_GetItem(kw, pos); if (!key) return 0; #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } #endif return 1; } while (PyDict_Next(kw, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if (!kw_allowed && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: #if PY_MAJOR_VERSION < 3 PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* GetAttr3 */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } #endif static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r; #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 int res = PyObject_GetOptionalAttr(o, n, &r); return (res != 0) ? r : __Pyx_NewRef(d); #else #if CYTHON_USE_TYPE_SLOTS if (likely(PyString_Check(n))) { r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (unlikely(!r) && likely(!PyErr_Occurred())) { r = __Pyx_NewRef(d); } return r; } #endif r = PyObject_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); #endif } /* RaiseUnexpectedTypeError */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) { __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, expected, obj_type_name); __Pyx_DECREF_TypeName(obj_type_name); return 0; } /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { __Pyx_TypeName obj_type_name; __Pyx_TypeName type_name; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); type_name = __Pyx_PyType_GetName(type); PyErr_Format(PyExc_TypeError, "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, obj_type_name, type_name); __Pyx_DECREF_TypeName(obj_type_name); __Pyx_DECREF_TypeName(type_name); return 0; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (unlikely(!j)) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; if (mm && mm->mp_subscript) { PyObject *r, *key = PyInt_FromSsize_t(i); if (unlikely(!key)) return NULL; r = mm->mp_subscript(o, key); Py_DECREF(key); return r; } if (likely(sm && sm->sq_item)) { if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { Py_ssize_t l = sm->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return sm->sq_item(o, i); } } #else if (is_list || !PyMapping_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* pybytes_as_double */ static double __Pyx_SlowPyString_AsDouble(PyObject *obj) { PyObject *float_value; #if PY_MAJOR_VERSION >= 3 float_value = PyFloat_FromString(obj); #else float_value = PyFloat_FromString(obj, 0); #endif if (likely(float_value)) { #if CYTHON_ASSUME_SAFE_MACROS double value = PyFloat_AS_DOUBLE(float_value); #else double value = PyFloat_AsDouble(float_value); #endif Py_DECREF(float_value); return value; } return (double)-1; } static const char* __Pyx__PyBytes_AsDouble_Copy(const char* start, char* buffer, Py_ssize_t length) { int last_was_punctuation = 1; Py_ssize_t i; for (i=0; i < length; i++) { char chr = start[i]; int is_punctuation = (chr == '_') | (chr == '.') | (chr == 'e') | (chr == 'E'); *buffer = chr; buffer += (chr != '_'); if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure; last_was_punctuation = is_punctuation; } if (unlikely(last_was_punctuation)) goto parse_failure; *buffer = '\0'; return buffer; parse_failure: return NULL; } static double __Pyx__PyBytes_AsDouble_inf_nan(const char* start, Py_ssize_t length) { int matches = 1; char sign = start[0]; int is_signed = (sign == '+') | (sign == '-'); start += is_signed; length -= is_signed; switch (start[0]) { #ifdef Py_NAN case 'n': case 'N': if (unlikely(length != 3)) goto parse_failure; matches &= (start[1] == 'a' || start[1] == 'A'); matches &= (start[2] == 'n' || start[2] == 'N'); if (unlikely(!matches)) goto parse_failure; return (sign == '-') ? -Py_NAN : Py_NAN; #endif case 'i': case 'I': if (unlikely(length < 3)) goto parse_failure; matches &= (start[1] == 'n' || start[1] == 'N'); matches &= (start[2] == 'f' || start[2] == 'F'); if (likely(length == 3 && matches)) return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; if (unlikely(length != 8)) goto parse_failure; matches &= (start[3] == 'i' || start[3] == 'I'); matches &= (start[4] == 'n' || start[4] == 'N'); matches &= (start[5] == 'i' || start[5] == 'I'); matches &= (start[6] == 't' || start[6] == 'T'); matches &= (start[7] == 'y' || start[7] == 'Y'); if (unlikely(!matches)) goto parse_failure; return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': break; default: goto parse_failure; } return 0.0; parse_failure: return -1.0; } static CYTHON_INLINE int __Pyx__PyBytes_AsDouble_IsSpace(char ch) { return (ch == 0x20) | !((ch < 0x9) | (ch > 0xd)); } CYTHON_UNUSED static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length) { double value; Py_ssize_t i, digits; const char *last = start + length; char *end; while (__Pyx__PyBytes_AsDouble_IsSpace(*start)) start++; while (start < last - 1 && __Pyx__PyBytes_AsDouble_IsSpace(last[-1])) last--; length = last - start; if (unlikely(length <= 0)) goto fallback; value = __Pyx__PyBytes_AsDouble_inf_nan(start, length); if (unlikely(value == -1.0)) goto fallback; if (value != 0.0) return value; digits = 0; for (i=0; i < length; digits += start[i++] != '_'); if (likely(digits == length)) { value = PyOS_string_to_double(start, &end, NULL); } else if (digits < 40) { char number[40]; last = __Pyx__PyBytes_AsDouble_Copy(start, number, length); if (unlikely(!last)) goto fallback; value = PyOS_string_to_double(number, &end, NULL); } else { char *number = (char*) PyMem_Malloc((digits + 1) * sizeof(char)); if (unlikely(!number)) goto fallback; last = __Pyx__PyBytes_AsDouble_Copy(start, number, length); if (unlikely(!last)) { PyMem_Free(number); goto fallback; } value = PyOS_string_to_double(number, &end, NULL); PyMem_Free(number); } if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) { return value; } fallback: return __Pyx_SlowPyString_AsDouble(obj); } /* SliceTupleAndList */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) { Py_ssize_t start = *_start, stop = *_stop, length = *_length; if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; else if (stop > length) stop = length; *_length = stop - start; *_start = start; *_stop = stop; } static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( PyObject* src, Py_ssize_t start, Py_ssize_t stop) { Py_ssize_t length = PyList_GET_SIZE(src); __Pyx_crop_slice(&start, &stop, &length); if (length <= 0) { return PyList_New(0); } return __Pyx_PyList_FromArray(((PyListObject*)src)->ob_item + start, length); } static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice( PyObject* src, Py_ssize_t start, Py_ssize_t stop) { Py_ssize_t length = PyTuple_GET_SIZE(src); __Pyx_crop_slice(&start, &stop, &length); return __Pyx_PyTuple_FromArray(((PyTupleObject*)src)->ob_item + start, length); } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); else state = (PyGILState_STATE)0; #endif CYTHON_UNUSED_VAR(clineno); CYTHON_UNUSED_VAR(lineno); CYTHON_UNUSED_VAR(filename); CYTHON_MAYBE_UNUSED_VAR(nogil); __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* PyIntBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { CYTHON_MAYBE_UNUSED_VAR(intval); CYTHON_MAYBE_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long x; long a = PyInt_AS_LONG(op1); x = (long)((unsigned long)a + (unsigned long)b); if (likely((x^a) >= 0 || (x^b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif if (unlikely(__Pyx_PyLong_IsZero(op1))) { return __Pyx_NewRef(op2); } if (likely(__Pyx_PyLong_IsCompact(op1))) { a = __Pyx_PyLong_CompactValue(op1); } else { const digit* digits = __Pyx_PyLong_Digits(op1); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1); switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } } x = a + b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla + llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; #if CYTHON_COMPILING_IN_LIMITED_API double a = __pyx_PyFloat_AsDouble(op1); #else double a = PyFloat_AS_DOUBLE(op1); #endif double result; PyFPE_START_PROTECT("add", return NULL) result = ((double)a) + (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #endif /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* 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))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (!r) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } #endif /* PyObjectCall2Args */ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args[3] = {NULL, arg1, arg2}; return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* PyObjectCallMethod1 */ #if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2) static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); Py_DECREF(method); return result; } #endif static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { #if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2 PyObject *args[2] = {obj, arg}; (void) __Pyx_PyObject_GetMethod; (void) __Pyx_PyObject_CallOneArg; (void) __Pyx_PyObject_Call2Args; return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); #else PyObject *method = NULL, *result; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_Call2Args(method, obj, arg); Py_DECREF(method); return result; } if (unlikely(!method)) return NULL; return __Pyx__PyObject_CallMethod1(method, arg); #endif } /* append */ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { if (likely(PyList_CheckExact(L))) { if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; } else { PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x); if (unlikely(!retval)) return -1; Py_DECREF(retval); } return 0; } /* FixUpExtensionType */ #if CYTHON_USE_TYPE_SPECS static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { #if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API CYTHON_UNUSED_VAR(spec); CYTHON_UNUSED_VAR(type); #else const PyType_Slot *slot = spec->slots; while (slot && slot->slot && slot->slot != Py_tp_members) slot++; if (slot && slot->slot == Py_tp_members) { int changed = 0; #if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) const #endif PyMemberDef *memb = (PyMemberDef*) slot->pfunc; while (memb && memb->name) { if (memb->name[0] == '_' && memb->name[1] == '_') { #if PY_VERSION_HEX < 0x030900b1 if (strcmp(memb->name, "__weaklistoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_weaklistoffset = memb->offset; changed = 1; } else if (strcmp(memb->name, "__dictoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_dictoffset = memb->offset; changed = 1; } #if CYTHON_METH_FASTCALL else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); #if PY_VERSION_HEX >= 0x030800b4 type->tp_vectorcall_offset = memb->offset; #else type->tp_print = (printfunc) memb->offset; #endif changed = 1; } #endif #else if ((0)); #endif #if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON else if (strcmp(memb->name, "__module__") == 0) { PyObject *descr; assert(memb->type == T_OBJECT); assert(memb->flags == 0 || memb->flags == READONLY); descr = PyDescr_NewMember(type, memb); if (unlikely(!descr)) return -1; if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { Py_DECREF(descr); return -1; } Py_DECREF(descr); changed = 1; } #endif } memb++; } if (changed) PyType_Modified(type); } #endif return 0; } #endif /* FetchSharedCythonModule */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); } /* FetchCommonType */ static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t basicsize, Py_ssize_t expected_basicsize) { if (!PyType_Check(cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", name); return -1; } if (basicsize != expected_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", name); return -1; } return 0; } #if !CYTHON_USE_TYPE_SPECS static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* abi_module; const char* object_name; PyTypeObject *cached_type = NULL; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; object_name = strrchr(type->tp_name, '.'); object_name = object_name ? object_name+1 : type->tp_name; cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); if (cached_type) { if (__Pyx_VerifyCachedType( (PyObject *)cached_type, object_name, cached_type->tp_basicsize, type->tp_basicsize) < 0) { goto bad; } goto done; } if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) goto bad; Py_INCREF(type); cached_type = type; done: Py_DECREF(abi_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } #else static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *abi_module, *cached_type = NULL; const char* object_name = strrchr(spec->name, '.'); object_name = object_name ? object_name+1 : spec->name; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; cached_type = PyObject_GetAttrString(abi_module, object_name); if (cached_type) { Py_ssize_t basicsize; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); if (unlikely(!py_basicsize)) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; #else basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; #endif if (__Pyx_VerifyCachedType( cached_type, object_name, basicsize, spec->basicsize) < 0) { goto bad; } goto done; } if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); CYTHON_UNUSED_VAR(module); cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); if (unlikely(!cached_type)) goto bad; if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; done: Py_DECREF(abi_module); assert(cached_type == NULL || PyType_Check(cached_type)); return (PyTypeObject *) cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } #endif /* PyVectorcallFastCallDict */ #if CYTHON_METH_FASTCALL static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { PyObject *res = NULL; PyObject *kwnames; PyObject **newargs; PyObject **kwvalues; Py_ssize_t i, pos; size_t j; PyObject *key, *value; unsigned long keys_are_strings; Py_ssize_t nkw = PyDict_GET_SIZE(kw); newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); if (unlikely(newargs == NULL)) { PyErr_NoMemory(); return NULL; } for (j = 0; j < nargs; j++) newargs[j] = args[j]; kwnames = PyTuple_New(nkw); if (unlikely(kwnames == NULL)) { PyMem_Free(newargs); return NULL; } kwvalues = newargs + nargs; pos = i = 0; keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; while (PyDict_Next(kw, &pos, &key, &value)) { keys_are_strings &= Py_TYPE(key)->tp_flags; Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(kwnames, i, key); kwvalues[i] = value; i++; } if (unlikely(!keys_are_strings)) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); goto cleanup; } res = vc(func, newargs, nargs, kwnames); cleanup: Py_DECREF(kwnames); for (i = 0; i < nkw; i++) Py_DECREF(kwvalues[i]); PyMem_Free(newargs); return res; } static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { return vc(func, args, nargs, NULL); } return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif /* CythonFunctionShared */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { if (__Pyx_CyFunction_Check(func)) { return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; } else if (PyCFunction_Check(func)) { return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; } return 0; } #else static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API __Pyx_Py_XDECREF_SET( __Pyx_CyFunction_GetClassObj(f), ((classobj) ? __Pyx_NewRef(classobj) : NULL)); #else __Pyx_Py_XDECREF_SET( ((PyCMethodObject *) (f))->mm_class, (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif } static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { CYTHON_UNUSED_VAR(closure); if (unlikely(op->func_doc == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); if (unlikely(!op->func_doc)) return NULL; #else if (((PyCFunctionObject*)op)->m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #else op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } #endif } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (value == NULL) { value = Py_None; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_doc, value); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_name = PyObject_GetAttrString(op->func, "__name__"); #elif PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #else op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_name, value); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_qualname, value); return 0; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) return NULL; } Py_INCREF(op->func_dict); return op->func_dict; } static int __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL)) { PyErr_SetString(PyExc_TypeError, "function's dictionary may not be deleted"); return -1; } if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "setting function's dictionary to a non-dict"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_dict, value); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(op); CYTHON_UNUSED_VAR(context); Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) { PyObject* result = (op->func_code) ? op->func_code : Py_None; CYTHON_UNUSED_VAR(context); Py_INCREF(result); return result; } static int __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { int result = 0; PyObject *res = op->defaults_getter((PyObject *) op); if (unlikely(!res)) return -1; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS op->defaults_tuple = PyTuple_GET_ITEM(res, 0); Py_INCREF(op->defaults_tuple); op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); Py_INCREF(op->defaults_kwdict); #else op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); if (unlikely(!op->defaults_kwdict)) result = -1; } #endif Py_DECREF(res); return result; } static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->defaults_tuple; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->defaults_kwdict; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); if (!value || value == Py_None) { value = NULL; } else if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); __Pyx_Py_XDECREF_SET(op->func_annotations, value); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->func_annotations; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { int is_coroutine; CYTHON_UNUSED_VAR(context); if (op->func_is_coroutine) { return __Pyx_NewRef(op->func_is_coroutine); } is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; #if PY_VERSION_HEX >= 0x03050000 if (is_coroutine) { PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; fromlist = PyList_New(1); if (unlikely(!fromlist)) return NULL; Py_INCREF(marker); #if CYTHON_ASSUME_SAFE_MACROS PyList_SET_ITEM(fromlist, 0, marker); #else if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { Py_DECREF(marker); Py_DECREF(fromlist); return NULL; } #endif module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); Py_DECREF(fromlist); if (unlikely(!module)) goto ignore; op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); Py_DECREF(module); if (likely(op->func_is_coroutine)) { return __Pyx_NewRef(op->func_is_coroutine); } ignore: PyErr_Clear(); } #endif op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); return __Pyx_NewRef(op->func_is_coroutine); } #if CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_GetAttrString(op->func, "__module__"); } static int __Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_SetAttrString(op->func, "__module__", value); } #endif static PyGetSetDef __pyx_CyFunction_getsets[] = { {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, #if CYTHON_COMPILING_IN_LIMITED_API {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #endif {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif #if CYTHON_USE_TYPE_SPECS {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, #if CYTHON_METH_FASTCALL #if CYTHON_BACKPORT_VECTORCALL {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else #if !CYTHON_COMPILING_IN_LIMITED_API {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif #endif #endif #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, #else {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) { CYTHON_UNUSED_VAR(args); #if PY_MAJOR_VERSION >= 3 Py_INCREF(m->func_qualname); return m->func_qualname; #else return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); #endif } static PyMethodDef __pyx_CyFunction_methods[] = { {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, {0, 0, 0, 0} }; #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) #endif static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { #if !CYTHON_COMPILING_IN_LIMITED_API PyCFunctionObject *cf = (PyCFunctionObject*) op; #endif if (unlikely(op == NULL)) return NULL; #if CYTHON_COMPILING_IN_LIMITED_API op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); if (unlikely(!op->func)) return NULL; #endif op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; #if !CYTHON_COMPILING_IN_LIMITED_API cf->m_ml = ml; cf->m_self = (PyObject *) op; #endif Py_XINCREF(closure); op->func_closure = closure; #if !CYTHON_COMPILING_IN_LIMITED_API Py_XINCREF(module); cf->m_module = module; #endif op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API op->func_classobj = NULL; #else ((PyCMethodObject*)op)->mm_class = NULL; #endif op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults_pyobjects = 0; op->defaults_size = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; op->func_is_coroutine = NULL; #if CYTHON_METH_FASTCALL switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { case METH_NOARGS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; break; case METH_O: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; break; case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; break; case METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; break; case METH_VARARGS | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = NULL; break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); Py_DECREF(op); return NULL; } #endif return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func); #else Py_CLEAR(((PyCFunctionObject*)m)->m_module); #endif Py_CLEAR(m->func_dict); Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); #if !CYTHON_COMPILING_IN_LIMITED_API #if PY_VERSION_HEX < 0x030900B1 Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); #else { PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; ((PyCMethodObject *) (m))->mm_class = NULL; Py_XDECREF(cls); } #endif #endif Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); Py_CLEAR(m->func_is_coroutine); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_XDECREF(pydefaults[i]); PyObject_Free(m->defaults); m->defaults = NULL; } return 0; } static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) { if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); __Pyx_PyHeapTypeObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(m); } static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { Py_VISIT(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func); #else Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif Py_VISIT(m->func_dict); Py_VISIT(m->func_name); Py_VISIT(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); Py_VISIT(m->func_code); #if !CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); #endif Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); Py_VISIT(m->func_is_coroutine); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_VISIT(pydefaults[i]); } return 0; } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromFormat("", op->func_qualname, (void *)op); #else return PyString_FromFormat("", PyString_AsString(op->func_qualname), (void *)op); #endif } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *f = ((__pyx_CyFunctionObject*)func)->func; PyObject *py_name = NULL; PyCFunction meth; int flags; meth = PyCFunction_GetFunction(f); if (unlikely(!meth)) return NULL; flags = PyCFunction_GetFlags(f); if (unlikely(flags < 0)) return NULL; #else PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; int flags = f->m_ml->ml_flags; #endif Py_ssize_t size; switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 0)) return (*meth)(self, NULL); #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, size); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); #endif return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, size); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); #endif return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; } #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", py_name); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); #endif return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *self, *result; #if CYTHON_COMPILING_IN_LIMITED_API self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); if (unlikely(!self) && PyErr_Occurred()) return NULL; #else self = ((PyCFunctionObject*)func)->m_self; #endif result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); return result; } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; #if CYTHON_METH_FASTCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #if CYTHON_ASSUME_SAFE_MACROS return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); #else (void) &__Pyx_PyVectorcall_FastCallDict; return PyVectorcall_Call(func, args, kw); #endif } #endif if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; #if CYTHON_ASSUME_SAFE_MACROS argc = PyTuple_GET_SIZE(args); #else argc = PyTuple_Size(args); if (unlikely(!argc) < 0) return NULL; #endif new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); #if PY_MAJOR_VERSION > 2 PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); #else PyErr_SetString(PyExc_TypeError, "unbound method needs an argument"); #endif return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } #if CYTHON_METH_FASTCALL static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) { int ret = 0; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { if (unlikely(nargs < 1)) { PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); return -1; } ret = 1; } if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); return -1; } return ret; } static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } if (unlikely(nargs != 0)) { PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", def->ml_name, nargs); return NULL; } return def->ml_meth(self, NULL); } static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } if (unlikely(nargs != 1)) { PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", def->ml_name, nargs); return NULL; } return def->ml_meth(self, args[0]); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); } #endif #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_CyFunctionType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, {Py_tp_methods, (void *)__pyx_CyFunction_methods}, {Py_tp_members, (void *)__pyx_CyFunction_members}, {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, {0, 0}, }; static PyType_Spec __pyx_CyFunctionType_spec = { __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) _Py_TPFLAGS_HAVE_VECTORCALL | #endif Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, __pyx_CyFunctionType_slots }; #else static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, #if !CYTHON_METH_FASTCALL 0, #elif CYTHON_BACKPORT_VECTORCALL (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), #else offsetof(PyCFunctionObject, vectorcall), #endif 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif (reprfunc) __Pyx_CyFunction_repr, 0, 0, 0, 0, __Pyx_CyFunction_CallAsMethod, 0, 0, 0, 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL _Py_TPFLAGS_HAVE_VECTORCALL | #endif Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, 0, (traverseproc) __Pyx_CyFunction_traverse, (inquiry) __Pyx_CyFunction_clear, 0, #if PY_VERSION_HEX < 0x030500A0 offsetof(__pyx_CyFunctionObject, func_weakreflist), #else offsetof(PyCFunctionObject, m_weakreflist), #endif 0, 0, __pyx_CyFunction_methods, __pyx_CyFunction_members, __pyx_CyFunction_getsets, 0, 0, __Pyx_PyMethod_New, 0, offsetof(__pyx_CyFunctionObject, func_dict), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, #endif #if __PYX_NEED_TP_PRINT_SLOT 0, #endif #if PY_VERSION_HEX >= 0x030C0000 0, #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, #endif }; #endif static int __pyx_CyFunction_init(PyObject *module) { #if CYTHON_USE_TYPE_SPECS __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); #else CYTHON_UNUSED_VAR(module); __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #endif if (unlikely(__pyx_CyFunctionType == NULL)) { return -1; } return 0; } static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults = PyObject_Malloc(size); if (unlikely(!m->defaults)) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; m->defaults_size = size; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->func_annotations = dict; Py_INCREF(dict); } /* CythonFunction */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { PyObject *op = __Pyx_CyFunction_Init( PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { PyObject_GC_Track(op); } return op; } /* UnpackUnboundCMethod */ static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { PyObject *result; PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); if (unlikely(!selfless_args)) return NULL; result = PyObject_Call(method, selfless_args, kwargs); Py_DECREF(selfless_args); return result; } static PyMethodDef __Pyx_UnboundCMethod_Def = { "CythonUnboundCMethod", __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), METH_VARARGS | METH_KEYWORDS, NULL }; static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { PyObject *method; method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); if (unlikely(!method)) return -1; target->method = method; #if CYTHON_COMPILING_IN_CPYTHON #if PY_MAJOR_VERSION >= 3 if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) #else if (likely(!__Pyx_CyOrPyCFunction_Check(method))) #endif { PyMethodDescrObject *descr = (PyMethodDescrObject*) method; target->func = descr->d_method->ml_meth; target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); } else #endif #if CYTHON_COMPILING_IN_PYPY #else if (PyCFunction_Check(method)) #endif { PyObject *self; int self_found; #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY self = PyObject_GetAttrString(method, "__self__"); if (!self) { PyErr_Clear(); } #else self = PyCFunction_GET_SELF(method); #endif self_found = (self && self != Py_None); #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY Py_XDECREF(self); #endif if (self_found) { PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); if (unlikely(!unbound_method)) return -1; Py_DECREF(method); target->method = unbound_method; } } return 0; } /* CallUnboundCMethod0 */ static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { PyObject *args, *result = NULL; if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; #if CYTHON_ASSUME_SAFE_MACROS args = PyTuple_New(1); if (unlikely(!args)) goto bad; Py_INCREF(self); PyTuple_SET_ITEM(args, 0, self); #else args = PyTuple_Pack(1, self); if (unlikely(!args)) goto bad; #endif result = __Pyx_PyObject_Call(cfunc->method, args, NULL); Py_DECREF(args); bad: return result; } /* UnicodeAsUCS4 */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) { Py_ssize_t length; #if CYTHON_PEP393_ENABLED length = PyUnicode_GET_LENGTH(x); if (likely(length == 1)) { return PyUnicode_READ_CHAR(x, 0); } #else length = PyUnicode_GET_SIZE(x); if (likely(length == 1)) { return PyUnicode_AS_UNICODE(x)[0]; } #if Py_UNICODE_SIZE == 2 else if (PyUnicode_GET_SIZE(x) == 2) { Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0]; if (high_val >= 0xD800 && high_val <= 0xDBFF) { Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1]; if (low_val >= 0xDC00 && low_val <= 0xDFFF) { return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1))); } } } #endif #endif PyErr_Format(PyExc_ValueError, "only single character unicode strings can be converted to Py_UCS4, " "got length %" CYTHON_FORMAT_SSIZE_T "d", length); return (Py_UCS4)-1; } /* object_ord */ static long __Pyx__PyObject_Ord(PyObject* c) { Py_ssize_t size; if (PyBytes_Check(c)) { size = PyBytes_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyBytes_AS_STRING(c)[0]; } #if PY_MAJOR_VERSION < 3 } else if (PyUnicode_Check(c)) { return (long)__Pyx_PyUnicode_AsPy_UCS4(c); #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) } else if (PyByteArray_Check(c)) { size = PyByteArray_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyByteArray_AS_STRING(c)[0]; } #endif } else { __Pyx_TypeName c_type_name = __Pyx_PyType_GetName(Py_TYPE(c)); PyErr_Format(PyExc_TypeError, "ord() expected string of length 1, but " __Pyx_FMT_TYPENAME " found", c_type_name); __Pyx_DECREF_TypeName(c_type_name); return (long)(Py_UCS4)-1; } PyErr_Format(PyExc_TypeError, "ord() expected a character, but string of length %zd found", size); return (long)(Py_UCS4)-1; } /* 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 /* pyobject_as_double */ static double __Pyx__PyObject_AsDouble(PyObject* obj) { if (PyUnicode_CheckExact(obj)) { return __Pyx_PyUnicode_AsDouble(obj); } else if (PyBytes_CheckExact(obj)) { return __Pyx_PyBytes_AsDouble(obj); } else if (PyByteArray_CheckExact(obj)) { return __Pyx_PyByteArray_AsDouble(obj); } else { PyObject* float_value; #if !CYTHON_USE_TYPE_SLOTS float_value = PyNumber_Float(obj); if ((0)) goto bad; (void)__Pyx_PyObject_CallOneArg; #else PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number; if (likely(nb) && likely(nb->nb_float)) { float_value = nb->nb_float(obj); if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) { __Pyx_TypeName float_value_type_name = __Pyx_PyType_GetName(Py_TYPE(float_value)); PyErr_Format(PyExc_TypeError, "__float__ returned non-float (type " __Pyx_FMT_TYPENAME ")", float_value_type_name); __Pyx_DECREF_TypeName(float_value_type_name); Py_DECREF(float_value); goto bad; } } else { float_value = __Pyx_PyObject_CallOneArg((PyObject*)&PyFloat_Type, obj); } #endif if (likely(float_value)) { double value = PyFloat_AS_DOUBLE(float_value); Py_DECREF(float_value); return value; } } bad: return (double)-1; } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *module = 0; PyObject *empty_dict = 0; PyObject *empty_list = 0; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (unlikely(!py_import)) goto bad; if (!from_list) { empty_list = PyList_New(0); if (unlikely(!empty_list)) goto bad; from_list = empty_list; } #endif empty_dict = PyDict_New(); if (unlikely(!empty_dict)) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { module = PyImport_ImportModuleLevelObject( name, __pyx_d, empty_dict, from_list, 1); if (unlikely(!module)) { if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (unlikely(!py_level)) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, __pyx_d, empty_dict, from_list, level); #endif } } bad: Py_XDECREF(empty_dict); Py_XDECREF(empty_list); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif return module; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { const char* module_name_str = 0; PyObject* module_name = 0; PyObject* module_dot = 0; PyObject* full_name = 0; PyErr_Clear(); module_name_str = PyModule_GetName(module); if (unlikely(!module_name_str)) { goto modbad; } module_name = PyUnicode_FromString(module_name_str); if (unlikely(!module_name)) { goto modbad; } module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__11); 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; } /* 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_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; } #endif if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (object_getstate != getstate) { goto __PYX_GOOD; } } #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) { __Pyx_TypeName type_obj_name = __Pyx_PyType_GetName((PyTypeObject*)type_obj); PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); __Pyx_DECREF_TypeName(type_obj_name); } ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); Py_XDECREF(object_getstate); Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } #endif /* SetVTable */ static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { PyObject *ob = PyCapsule_New(vtable, 0, 0); if (unlikely(!ob)) goto bad; #if CYTHON_COMPILING_IN_LIMITED_API if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* GetVTable */ static void* __Pyx_GetVtable(PyTypeObject *type) { void* ptr; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); #else PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); #endif if (!ob) goto bad; ptr = PyCapsule_GetPointer(ob, 0); if (!ptr && !PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); Py_DECREF(ob); return ptr; bad: Py_XDECREF(ob); return NULL; } /* MergeVTables */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_MergeVtables(PyTypeObject *type) { int i; void** base_vtables; __Pyx_TypeName tp_base_name; __Pyx_TypeName base_name; void* unknown = (void*)-1; PyObject* bases = type->tp_bases; int base_depth = 0; { PyTypeObject* base = type->tp_base; while (base) { base_depth += 1; base = base->tp_base; } } base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); base_vtables[0] = unknown; for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); if (base_vtable != NULL) { int j; PyTypeObject* base = type->tp_base; for (j = 0; j < base_depth; j++) { if (base_vtables[j] == unknown) { base_vtables[j] = __Pyx_GetVtable(base); base_vtables[j + 1] = unknown; } if (base_vtables[j] == base_vtable) { break; } else if (base_vtables[j] == NULL) { goto bad; } base = base->tp_base; } } } PyErr_Clear(); free(base_vtables); return 0; bad: tp_base_name = __Pyx_PyType_GetName(type->tp_base); base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); PyErr_Format(PyExc_TypeError, "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); __Pyx_DECREF_TypeName(tp_base_name); __Pyx_DECREF_TypeName(base_name); free(base_vtables); return -1; } #endif /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType_3_0_10 #define __PYX_HAVE_RT_ImportType_3_0_10 static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; Py_ssize_t itemsize; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; PyObject *py_itemsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #if !CYTHON_COMPILING_IN_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; itemsize = ((PyTypeObject *)result)->tp_itemsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); if (!py_itemsize) goto bad; itemsize = PyLong_AsSsize_t(py_itemsize); Py_DECREF(py_itemsize); py_itemsize = 0; if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if (itemsize) { if (size % alignment) { alignment = size % alignment; } if (itemsize < (Py_ssize_t)alignment) itemsize = (Py_ssize_t)alignment; } if ((size_t)(basicsize + itemsize) < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize+itemsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd-%zd from PyObject", module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* ImportDottedModule */ #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; if (unlikely(PyErr_Occurred())) { PyErr_Clear(); } if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) { partial_name = name; } else { slice = PySequence_GetSlice(parts_tuple, 0, count); if (unlikely(!slice)) goto bad; sep = PyUnicode_FromStringAndSize(".", 1); if (unlikely(!sep)) goto bad; partial_name = PyUnicode_Join(sep, slice); } PyErr_Format( #if PY_MAJOR_VERSION < 3 PyExc_ImportError, "No module named '%s'", PyString_AS_STRING(partial_name)); #else #if PY_VERSION_HEX >= 0x030600B1 PyExc_ModuleNotFoundError, #else PyExc_ImportError, #endif "No module named '%U'", partial_name); #endif bad: Py_XDECREF(sep); Py_XDECREF(slice); Py_XDECREF(partial_name); return NULL; } #endif #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { PyObject *imported_module; #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) return NULL; imported_module = __Pyx_PyDict_GetItemStr(modules, name); Py_XINCREF(imported_module); #else imported_module = PyImport_GetModule(name); #endif return imported_module; } #endif #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { Py_ssize_t i, nparts; nparts = PyTuple_GET_SIZE(parts_tuple); for (i=1; i < nparts && module; i++) { PyObject *part, *submodule; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS part = PyTuple_GET_ITEM(parts_tuple, i); #else part = PySequence_ITEM(parts_tuple, i); #endif submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(part); #endif Py_DECREF(module); module = submodule; } if (unlikely(!module)) { return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); } return module; } #endif static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { #if PY_MAJOR_VERSION < 3 PyObject *module, *from_list, *star = __pyx_n_s__12; CYTHON_UNUSED_VAR(parts_tuple); from_list = PyList_New(1); if (unlikely(!from_list)) return NULL; Py_INCREF(star); PyList_SET_ITEM(from_list, 0, star); module = __Pyx_Import(name, from_list, 0); Py_DECREF(from_list); return module; #else PyObject *imported_module; PyObject *module = __Pyx_Import(name, NULL, 0); if (!parts_tuple || unlikely(!module)) return module; imported_module = __Pyx__ImportDottedModule_Lookup(name); if (likely(imported_module)) { Py_DECREF(module); return imported_module; } PyErr_Clear(); return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); #endif } static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 PyObject *module = __Pyx__ImportDottedModule_Lookup(name); if (likely(module)) { PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec_2); if (likely(spec)) { PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing); if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { Py_DECREF(spec); spec = NULL; } Py_XDECREF(unsafe); } if (likely(!spec)) { PyErr_Clear(); return module; } Py_DECREF(spec); Py_DECREF(module); } else if (PyErr_Occurred()) { PyErr_Clear(); } #endif return __Pyx__ImportDottedModule(name, parts_tuple); } /* PatchModuleWithCoroutine */ static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) int result; PyObject *globals, *result_obj; globals = PyDict_New(); if (unlikely(!globals)) goto ignore; result = PyDict_SetItemString(globals, "_cython_coroutine_type", #ifdef __Pyx_Coroutine_USED (PyObject*)__pyx_CoroutineType); #else Py_None); #endif if (unlikely(result < 0)) goto ignore; result = PyDict_SetItemString(globals, "_cython_generator_type", #ifdef __Pyx_Generator_USED (PyObject*)__pyx_GeneratorType); #else Py_None); #endif if (unlikely(result < 0)) goto ignore; if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; result_obj = PyRun_String(py_code, Py_file_input, globals, globals); if (unlikely(!result_obj)) goto ignore; Py_DECREF(result_obj); Py_DECREF(globals); return module; ignore: Py_XDECREF(globals); PyErr_WriteUnraisable(module); if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { Py_DECREF(module); module = NULL; } #else py_code++; #endif return module; } /* PatchInspect */ static PyObject* __Pyx_patch_inspect(PyObject* module) { #if defined(__Pyx_Generator_USED) && (!defined(CYTHON_PATCH_INSPECT) || CYTHON_PATCH_INSPECT) static int inspect_patched = 0; if (unlikely((!inspect_patched) && module)) { module = __Pyx_Coroutine_patch_module( module, "" "old_types = getattr(_module.isgenerator, '_cython_generator_types', None)\n" "if old_types is None or not isinstance(old_types, set):\n" " old_types = set()\n" " def cy_wrap(orig_func, type=type, cython_generator_types=old_types):\n" " def cy_isgenerator(obj): return type(obj) in cython_generator_types or orig_func(obj)\n" " cy_isgenerator._cython_generator_types = cython_generator_types\n" " return cy_isgenerator\n" " _module.isgenerator = cy_wrap(_module.isgenerator)\n" "old_types.add(_cython_generator_type)\n" ); inspect_patched = 1; } #else if ((0)) return __Pyx_Coroutine_patch_module(module, NULL); #endif return module; } /* CalculateMetaclass */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *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) continue; #endif if (!metaclass) { metaclass = tmptype; continue; } if (PyType_IsSubtype(metaclass, tmptype)) continue; if (PyType_IsSubtype(tmptype, metaclass)) { metaclass = tmptype; continue; } PyErr_SetString(PyExc_TypeError, "metaclass conflict: " "the metaclass of a derived class " "must be a (non-strict) subclass " "of the metaclasses of all its bases"); return NULL; } if (!metaclass) { #if PY_MAJOR_VERSION < 3 metaclass = &PyClass_Type; #else metaclass = &PyType_Type; #endif } Py_INCREF((PyObject*) metaclass); return (PyObject*) metaclass; } /* 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 /* Py3ClassCreate */ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { PyObject *ns; if (metaclass) { PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_n_s_prepare); if (prep) { PyObject *pargs[3] = {NULL, name, bases}; ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); Py_DECREF(prep); } else { if (unlikely(PyErr_Occurred())) return NULL; ns = PyDict_New(); } } else { ns = PyDict_New(); } 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; 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) { metaclass = owned_metaclass; } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { PyErr_Clear(); } else { return NULL; } } if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); Py_XDECREF(owned_metaclass); if (unlikely(!metaclass)) return NULL; owned_metaclass = metaclass; } 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 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; } /* 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; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } #endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, PyObject *firstlineno, PyObject *name) { PyObject *replace = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; replace = PyObject_GetAttrString(code, "replace"); if (likely(replace)) { PyObject *result; result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); Py_DECREF(replace); return result; } PyErr_Clear(); #if __PYX_LIMITED_VERSION_HEX < 0x030780000 { PyObject *compiled = NULL, *result = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; compiled = Py_CompileString( "out = type(code)(\n" " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" " code.co_lnotab)\n", "", Py_file_input); if (!compiled) return NULL; result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); Py_DECREF(compiled); if (!result) PyErr_Print(); Py_DECREF(result); result = PyDict_GetItemString(scratch_dict, "out"); if (result) Py_INCREF(result); return result; } #else return NULL; #endif } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; PyObject *replace = NULL, *getframe = NULL, *frame = NULL; PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { (void) __pyx_cfilenm; (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); code_object = Py_CompileString("_getframe()", filename, Py_eval_input); if (unlikely(!code_object)) goto bad; py_py_line = PyLong_FromLong(py_line); if (unlikely(!py_py_line)) goto bad; py_funcname = PyUnicode_FromString(funcname); if (unlikely(!py_funcname)) goto bad; dict = PyDict_New(); if (unlikely(!dict)) goto bad; { PyObject *old_code_object = code_object; code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); Py_DECREF(old_code_object); } if (unlikely(!code_object)) goto bad; getframe = PySys_GetObject("_getframe"); if (unlikely(!getframe)) goto bad; if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; frame = PyEval_EvalCode(code_object, dict, dict); if (unlikely(!frame) || frame == Py_None) goto bad; success = 1; bad: PyErr_Restore(exc_type, exc_value, exc_traceback); Py_XDECREF(code_object); Py_XDECREF(py_py_line); Py_XDECREF(py_funcname); Py_XDECREF(dict); Py_XDECREF(replace); if (success) { PyTraceBack_Here( (struct _frame*)frame); } Py_XDECREF(frame); } #else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { case 2: if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } } #endif if ((sizeof(int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (int) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (int) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (int) -1; } else { stepval = __Pyx_NewRef(v); } val = (int) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntToPy */ 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" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { case 2: if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(long) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } } #endif if ((sizeof(long) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (long) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (long) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (long) -1; } else { stepval = __Pyx_NewRef(v); } val = (long) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((long) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((long) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int32_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int32_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int32_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int32_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(int32_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 } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int64_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int64_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int64_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int64_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(int64_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 } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_char(unsigned char value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const unsigned char neg_one = (unsigned char) -1, const_zero = (unsigned char) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned char) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned char) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned char) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned char) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(unsigned char), 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(unsigned char)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint8_t(uint8_t value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint8_t neg_one = (uint8_t) -1, const_zero = (uint8_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint8_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint8_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(uint8_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint8_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(uint8_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(uint8_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 } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint32_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint32_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(uint32_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(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 } } /* CIntFromPy */ static CYTHON_INLINE unsigned char __Pyx_PyInt_As_unsigned_char(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const unsigned char neg_one = (unsigned char) -1, const_zero = (unsigned char) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if ((sizeof(unsigned char) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(unsigned char, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned char) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(unsigned char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { case 2: if ((8 * sizeof(unsigned char) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) >= 2 * PyLong_SHIFT)) { return (unsigned char) (((((unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0])); } } break; case 3: if ((8 * sizeof(unsigned char) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) >= 3 * PyLong_SHIFT)) { return (unsigned char) (((((((unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0])); } } break; case 4: if ((8 * sizeof(unsigned char) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) >= 4 * PyLong_SHIFT)) { return (unsigned char) (((((((((unsigned char)digits[3]) << PyLong_SHIFT) | (unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0])); } } break; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned char) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(unsigned char) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(unsigned char) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(unsigned char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: if ((8 * sizeof(unsigned char) - 1 > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) - 1 > 2 * PyLong_SHIFT)) { return (unsigned char) (((unsigned char)-1)*(((((unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case 2: if ((8 * sizeof(unsigned char) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) - 1 > 2 * PyLong_SHIFT)) { return (unsigned char) ((((((unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case -3: if ((8 * sizeof(unsigned char) - 1 > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) - 1 > 3 * PyLong_SHIFT)) { return (unsigned char) (((unsigned char)-1)*(((((((unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case 3: if ((8 * sizeof(unsigned char) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) - 1 > 3 * PyLong_SHIFT)) { return (unsigned char) ((((((((unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case -4: if ((8 * sizeof(unsigned char) - 1 > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) - 1 > 4 * PyLong_SHIFT)) { return (unsigned char) (((unsigned char)-1)*(((((((((unsigned char)digits[3]) << PyLong_SHIFT) | (unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; case 4: if ((8 * sizeof(unsigned char) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(unsigned char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(unsigned char) - 1 > 4 * PyLong_SHIFT)) { return (unsigned char) ((((((((((unsigned char)digits[3]) << PyLong_SHIFT) | (unsigned char)digits[2]) << PyLong_SHIFT) | (unsigned char)digits[1]) << PyLong_SHIFT) | (unsigned char)digits[0]))); } } break; } } #endif if ((sizeof(unsigned char) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(unsigned char) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned char, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { unsigned char val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (unsigned char) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (unsigned char) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned char) -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 (unsigned char) -1; } else { stepval = __Pyx_NewRef(v); } val = (unsigned char) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(unsigned char) * 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 |= ((unsigned char) 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(unsigned char) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((unsigned char) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((unsigned char) 1) << (sizeof(unsigned char) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } return (unsigned char) -1; } } else { unsigned char val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned char) -1; val = __Pyx_PyInt_As_unsigned_char(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned char"); return (unsigned char) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned char"); return (unsigned char) -1; } /* CIntFromPy */ static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if ((sizeof(int32_t) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int32_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int32_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int32_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(int32_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int32_t) >= 2 * PyLong_SHIFT)) { return (int32_t) (((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); } } break; case 3: if ((8 * sizeof(int32_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int32_t) >= 3 * PyLong_SHIFT)) { return (int32_t) (((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); } } break; case 4: if ((8 * sizeof(int32_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_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(int32_t) >= 4 * PyLong_SHIFT)) { return (int32_t) (((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); } } break; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int32_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(int32_t) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int32_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(int32_t) - 1 > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT)) { return (int32_t) (((int32_t)-1)*(((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); } } break; case 2: if ((8 * sizeof(int32_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT)) { return (int32_t) ((((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); } } break; case -3: if ((8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT)) { return (int32_t) (((int32_t)-1)*(((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); } } break; case 3: if ((8 * sizeof(int32_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT)) { return (int32_t) ((((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); } } break; case -4: if ((8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_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(int32_t) - 1 > 4 * PyLong_SHIFT)) { return (int32_t) (((int32_t)-1)*(((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); } } break; case 4: if ((8 * sizeof(int32_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int32_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(int32_t) - 1 > 4 * PyLong_SHIFT)) { return (int32_t) ((((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); } } break; } } #endif if ((sizeof(int32_t) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int32_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(int32_t) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { int32_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (int32_t) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (int32_t) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int32_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 (int32_t) -1; } else { stepval = __Pyx_NewRef(v); } val = (int32_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(int32_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 |= ((int32_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(int32_t) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((int32_t) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((int32_t) 1) << (sizeof(int32_t) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } return (int32_t) -1; } } else { int32_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int32_t) -1; val = __Pyx_PyInt_As_int32_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int32_t"); return (int32_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int32_t"); return (int32_t) -1; } /* CIntFromPy */ static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if ((sizeof(int64_t) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int64_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int64_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int64_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(int64_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int64_t) >= 2 * PyLong_SHIFT)) { return (int64_t) (((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); } } break; case 3: if ((8 * sizeof(int64_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int64_t) >= 3 * PyLong_SHIFT)) { return (int64_t) (((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); } } break; case 4: if ((8 * sizeof(int64_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_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(int64_t) >= 4 * PyLong_SHIFT)) { return (int64_t) (((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); } } break; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int64_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(int64_t) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int64_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(int64_t) - 1 > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT)) { return (int64_t) (((int64_t)-1)*(((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); } } break; case 2: if ((8 * sizeof(int64_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT)) { return (int64_t) ((((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); } } break; case -3: if ((8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT)) { return (int64_t) (((int64_t)-1)*(((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); } } break; case 3: if ((8 * sizeof(int64_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT)) { return (int64_t) ((((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); } } break; case -4: if ((8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_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(int64_t) - 1 > 4 * PyLong_SHIFT)) { return (int64_t) (((int64_t)-1)*(((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); } } break; case 4: if ((8 * sizeof(int64_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(int64_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(int64_t) - 1 > 4 * PyLong_SHIFT)) { return (int64_t) ((((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); } } break; } } #endif if ((sizeof(int64_t) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(int64_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(int64_t) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(int64_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { int64_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (int64_t) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (int64_t) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int64_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 (int64_t) -1; } else { stepval = __Pyx_NewRef(v); } val = (int64_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(int64_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 |= ((int64_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(int64_t) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((int64_t) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((int64_t) 1) << (sizeof(int64_t) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } return (int64_t) -1; } } else { int64_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int64_t) -1; val = __Pyx_PyInt_As_int64_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int64_t"); return (int64_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int64_t"); return (int64_t) -1; } /* CIntFromPy */ static CYTHON_INLINE uint8_t __Pyx_PyInt_As_uint8_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint8_t neg_one = (uint8_t) -1, const_zero = (uint8_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if ((sizeof(uint8_t) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(uint8_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint8_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) >= 2 * PyLong_SHIFT)) { return (uint8_t) (((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; case 3: if ((8 * sizeof(uint8_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) >= 3 * PyLong_SHIFT)) { return (uint8_t) (((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; case 4: if ((8 * sizeof(uint8_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) >= 4 * PyLong_SHIFT)) { return (uint8_t) (((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (uint8_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(uint8_t) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) - 1 > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT)) { return (uint8_t) (((uint8_t)-1)*(((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 2: if ((8 * sizeof(uint8_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT)) { return (uint8_t) ((((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case -3: if ((8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT)) { return (uint8_t) (((uint8_t)-1)*(((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 3: if ((8 * sizeof(uint8_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT)) { return (uint8_t) ((((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case -4: if ((8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) - 1 > 4 * PyLong_SHIFT)) { return (uint8_t) (((uint8_t)-1)*(((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 4: if ((8 * sizeof(uint8_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) - 1 > 4 * PyLong_SHIFT)) { return (uint8_t) ((((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; } } #endif if ((sizeof(uint8_t) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(uint8_t) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { uint8_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (uint8_t) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (uint8_t) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (uint8_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 (uint8_t) -1; } else { stepval = __Pyx_NewRef(v); } val = (uint8_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(uint8_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 |= ((uint8_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(uint8_t) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((uint8_t) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((uint8_t) 1) << (sizeof(uint8_t) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } return (uint8_t) -1; } } else { uint8_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (uint8_t) -1; val = __Pyx_PyInt_As_uint8_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint8_t"); return (uint8_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint8_t"); return (uint8_t) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const char neg_one = (char) -1, const_zero = (char) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(char) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(char) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(char) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(char), 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(char)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if ((sizeof(uint32_t) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint32_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(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 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (uint32_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(uint32_t) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_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 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 -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 -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; } } #endif 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))) { __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { uint32_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (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; } return (uint32_t) -1; } } else { uint32_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (uint32_t) -1; val = __Pyx_PyInt_As_uint32_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint32_t"); return (uint32_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint32_t"); return (uint32_t) -1; } /* FormatTypeName */ #if CYTHON_COMPILING_IN_LIMITED_API static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp) { PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_n_s_name_2); if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { PyErr_Clear(); Py_XDECREF(name); name = __Pyx_NewRef(__pyx_n_s__88); } return name; } #endif /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (cls == a || cls == b) return 1; mro = cls->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { PyObject *base = PyTuple_GET_ITEM(mro, i); if (base == (PyObject *)a || base == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { if (exc_type1) { return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); } else { return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x030B00A4 return Py_Version & ~0xFFUL; #else const char* rt_version = Py_GetVersion(); unsigned long version = 0; unsigned long factor = 0x01000000UL; unsigned int digit = 0; int i = 0; while (factor) { while ('0' <= rt_version[i] && rt_version[i] <= '9') { digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); ++i; } version += factor * digit; if (rt_version[i] != '.') break; digit = 0; factor >>= 8; ++i; } return version; #endif } static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { const unsigned long MAJOR_MINOR = 0xFFFF0000UL; if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) return 0; if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) return 1; { char message[200]; PyOS_snprintf(message, sizeof(message), "compile time Python version %d.%d " "of module '%.100s' " "%s " "runtime version %d.%d", (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), __Pyx_MODULE_NAME, (allow_newer) ? "was newer than" : "does not match", (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) ); return PyErr_WarnEx(NULL, message, 1); } } /* InitStrings */ #if PY_MAJOR_VERSION >= 3 static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { if (t.is_unicode | t.is_str) { if (t.intern) { *str = PyUnicode_InternFromString(t.s); } else if (t.encoding) { *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); } else { *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); } } else { *str = PyBytes_FromStringAndSize(t.s, t.n - 1); } if (!*str) return -1; if (PyObject_Hash(*str) == -1) return -1; return 0; } #endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION >= 3 __Pyx_InitString(*t, t->p); #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; #endif ++t; } return 0; } #include static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { size_t len = strlen(s); if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "byte string is too long"); return -1; } return (Py_ssize_t) len; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return __Pyx_PyUnicode_FromStringAndSize(c_str, len); } static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " "The ability to return an instance of a strict subclass of int is deprecated, " "and may be removed in a future version of Python.", result_type_name)) { __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", type_name, type_name, result_type_name); __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS if (likely(__Pyx_PyLong_IsCompact(b))) { return __Pyx_PyLong_CompactValue(b); } else { const digit* digits = __Pyx_PyLong_Digits(b); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } /* #### Code section: utility_code_pragmas_end ### */ #ifdef _MSC_VER #pragma warning( pop ) #endif /* #### Code section: end ### */ #endif /* Py_PYTHON_H */ pyliblo3-master/pyliblo3/_liblo.pxd000066400000000000000000000104241465273517200176330ustar00rootroot00000000000000# # pyliblo - Python bindings for the liblo OSC library # # Copyright (C) 2007-2011 Dominic Sacré # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation; either version 2.1 of the # License, or (at your option) any later version. # from libc.stdint cimport int32_t, uint32_t, int64_t, uint8_t from libc.stdio cimport const_char cdef extern from 'lo/lo.h': # type definitions ctypedef void *lo_server ctypedef void *lo_server_thread ctypedef void *lo_method ctypedef void *lo_address ctypedef void *lo_message ctypedef void *lo_blob ctypedef void *lo_bundle ctypedef struct lo_timetag: uint32_t sec uint32_t frac ctypedef union lo_arg: int32_t i int64_t h float f double d unsigned char c char s uint8_t m[4] lo_timetag t cdef enum: LO_DEFAULT LO_UDP LO_UNIX LO_TCP ctypedef void(*lo_err_handler)(int num, const_char *msg, const_char *where) ctypedef int(*lo_method_handler)(const_char *path, const_char *types, lo_arg **argv, int argc, lo_message msg, void *user_data) ctypedef int(*lo_bundle_start_handler)(lo_timetag time, void *user_data) ctypedef int(*lo_bundle_end_handler)(void *user_data) # send int lo_send_message_from(lo_address targ, lo_server serv, char *path, lo_message msg) int lo_send_bundle_from(lo_address targ, lo_server serv, lo_bundle b) # server lo_server lo_server_new_with_proto(char *port, int proto, lo_err_handler err_h) void lo_server_free(lo_server s) char *lo_server_get_url(lo_server s) int lo_server_get_port(lo_server s) int lo_server_get_protocol(lo_server s) lo_method lo_server_add_method(lo_server s, char *path, char *typespec, lo_method_handler h, void *user_data) void lo_server_del_method(lo_server s, char *path, char *typespec) int lo_server_add_bundle_handlers(lo_server s, lo_bundle_start_handler sh, lo_bundle_end_handler eh, void *user_data) int lo_server_recv(lo_server s) nogil int lo_server_recv_noblock(lo_server s, int timeout) nogil int lo_server_get_socket_fd(lo_server s) # server thread lo_server_thread lo_server_thread_new_with_proto(char *port, int proto, lo_err_handler err_h) void lo_server_thread_free(lo_server_thread st) lo_server lo_server_thread_get_server(lo_server_thread st) void lo_server_thread_start(lo_server_thread st) void lo_server_thread_stop(lo_server_thread st) # address lo_address lo_address_new(char *host, char *port) lo_address lo_address_new_with_proto(int proto, char *host, char *port) lo_address lo_address_new_from_url(char *url) void lo_address_free(lo_address) char *lo_address_get_url(lo_address a) char *lo_address_get_hostname(lo_address a) char *lo_address_get_port(lo_address a) int lo_address_get_protocol(lo_address a) const_char* lo_address_errstr(lo_address a) # message lo_message lo_message_new() void lo_message_free(lo_message) void lo_message_add_int32(lo_message m, int32_t a) void lo_message_add_int64(lo_message m, int64_t a) void lo_message_add_float(lo_message m, float a) void lo_message_add_double(lo_message m, double a) void lo_message_add_char(lo_message m, char a) void lo_message_add_string(lo_message m, char *a) void lo_message_add_symbol(lo_message m, char *a) void lo_message_add_true(lo_message m) void lo_message_add_false(lo_message m) void lo_message_add_nil(lo_message m) void lo_message_add_infinitum(lo_message m) void lo_message_add_midi(lo_message m, uint8_t a[4]) void lo_message_add_timetag(lo_message m, lo_timetag a) void lo_message_add_blob(lo_message m, lo_blob a) lo_address lo_message_get_source(lo_message m) # blob lo_blob lo_blob_new(int32_t size, void *data) void lo_blob_free(lo_blob b) void *lo_blob_dataptr(lo_blob b) uint32_t lo_blob_datasize(lo_blob b) # bundle lo_bundle lo_bundle_new(lo_timetag tt) void lo_bundle_free(lo_bundle b) void lo_bundle_add_message(lo_bundle b, char *path, lo_message m) # timetag void lo_timetag_now(lo_timetag *t) pyliblo3-master/pyliblo3/_liblo.pyi000066400000000000000000000065761465273517200176560ustar00rootroot00000000000000 class Callback: def __init__(self, func: Callable, user_data: Any): ... def time() -> float: ... def send(target: Address | tuple[str, str] | int, str, *args) -> None: ... class ServerError(Exception): def __init__(self, num: int, msg: str, where: str): ... # decorator to register callbacks class make_method: def __init__(self, path: str, types: str, user_data: Any = None): ... def __call__(self, f: Callable) -> Callable: ... # common base class for both Server and ServerThread class _ServerBase: def __init__(self, reg_methods: bool = True): ... def register_methods(self, obj: _ServerBase = None) -> None: ... def get_url(self) -> str: ... def get_port(self) -> int: ... def get_protocol(self) -> int: ... def fileno(self) -> int: ... def add_method(self, path: str, typespec: str, func: Callable, user_data: Any = None) -> None: ... def del_method(self, path: str, typespec: str | None = None) -> None: ... def add_bundle_handlers(self, start_handler: Callable, end_handler: Callable, user_data=None) -> None: ... def send(self, target: Address | tuple[str, int] | str, *args) -> None: ... @property def url(self) -> str: ... @property def port(self) -> int: ... @property def protocol(self) -> int: ... class Server(_ServerBase): def __init__(self, port: int = None, proto: int | str = LO_DEFAULT, reg_methods: bool = True): ... def __dealloc__(self): ... def free(self) -> None: ... def recv(self, timeout: int | float | None = None) -> bool: ... class ServerThread(_ServerBase): def __init__(self, port: int = None, proto: int | str = LO_DEFAULT, reg_methods: bool = True): ... def __dealloc__(self): ... def free(self) -> None: ... def start(self) -> None: ... def stop(self) -> None: ... class AddressError(Exception): def __init__(self, msg: str): ... class Address: """ An Address represents a destination for a message Possible forms: * `Address(hostname: str, port: int, proto: [int | str] = LO_UDP`) * `Address(port: int)` # Assumes localhost * `Address(url: str)` # A URL of the form 'osc.udp://hostname:1234/' Create a new `Address` object from the given hostname/port or URL. Args: hostname: the target's hostname - the name or an IP of the form '127.0.0.0'. port: the port number of the target proto: one of the constants `LO_UDP`, `LO_TCP`, `LO_UNIX` or a string like 'UDP', 'TCP' or 'UNIX' url: a URL in liblo notation, e.g. `'osc.udp://hostname:1234/'`. Raises: AddressError: if the given parameters do not represent a valid address. """ cdef lo_address _address def __init__(self, addr: str | int, addr2: int = None, proto: int | str = None): ... def __dealloc__(self) -> None: ... def get_url(self) -> str: ... def get_hostname(self) -> str: ... def get_port(self) -> int | str: ... def get_protocol(self) -> int: ... @property def url(self) -> str: ... @property def hostname(self) -> str: ... @property def port(self) -> int: ... @property def protocol(self) -> int: ... class Message: def __init__(self, path: str, *args): ... def add(self, *args: tuple[str, Any] | int | float | str | bool) -> None: ... class Bundle: def __init__(self, *messages): ... def add(self, *args) -> None: ... pyliblo3-master/pyliblo3/_liblo.pyx000066400000000000000000001036301465273517200176620ustar00rootroot00000000000000# cython: embedsignature=True # # pyliblo3 - Python bindings for the lublo OSC library, based on pyliblo # # Original copyright: # # pyliblo - Python bindings for the liblo OSC library # # Copyright (C) 2007-2015 Dominic Sacré # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation; either version 2.1 of the # License, or (at your option) any later version. # __version__ = '0.16.1' from cpython cimport PY_VERSION_HEX cdef extern from 'Python.h': void PyEval_InitThreads() from libc.stdlib cimport malloc, free from libc.math cimport modf from libc.stdint cimport int32_t, int64_t from _liblo cimport * import inspect as _inspect import weakref as _weakref def _protostr_to_int(str proto): if proto == 'UDP': return LO_UDP elif proto == 'TCP': return LO_TCP elif proto == 'UNIX': return LO_UNIX else: raise ValueError(f"Proto {proto} not understood, expected one of 'UDP', 'TCP' or 'UNIX'") class _weakref_method: """ Weak reference to a function, including support for bound methods. """ __slots__ = ('_func', 'obj') def __init__(self, f): if _inspect.ismethod(f): self._func = f.__func__ self.obj = _weakref.ref(f.__self__) else: self._func = f self.obj = None @property def func(self): if self.obj: return self._func.__get__(self.obj(), self.obj().__class__) else: return self._func def __call__(self, *args, **kwargs): return self.func(*args, **kwargs) class struct: def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) cdef class Callback: """ Used internally to wrap a python function as a callback Args: func: the function to call user_data: any python object, will be passed to the callback as the last argument """ cdef object func cdef object user_data cdef int numargs cdef int has_varargs def __init__(self, func, user_data): self.func = _weakref_method(func) self.user_data = user_data, spec = _inspect.getfullargspec(func) numargs = len(spec.args) if _inspect.ismethod(func): numargs -= 1 self.numargs = numargs self.has_varargs = 1 if spec.varargs is not None else 0 cdef inline str _decode(s): # convert to standard string type, depending on python version if PY_VERSION_HEX >= 0x03000000 and isinstance(s, bytes): return s.decode() else: return s cdef bytes _encode(s): # convert unicode to bytestring if isinstance(s, unicode): return s.encode() else: return s # forward declarations cdef class _ServerBase cdef class Address cdef class Message cdef class Bundle # liblo protocol constants UDP = LO_UDP TCP = LO_TCP UNIX = LO_UNIX ################################################################################ # timetag ################################################################################ cdef lo_timetag _double_to_timetag(double f): cdef lo_timetag tt cdef double intr, frac frac = modf(f, &intr) tt.sec = intr tt.frac = (frac * 4294967296.0) return tt cdef double _timetag_to_double(lo_timetag tt): return tt.sec + ((tt.frac) / 4294967296.0) def time(): """ Return the current time as a floating point number (seconds since January 1, 1900). Returns: (float) The liblo timetag as a float, representing seconds since 1900 """ cdef lo_timetag tt lo_timetag_now(&tt) return _timetag_to_double(tt) ################################################################################ # send ################################################################################ cdef _send(target, _ServerBase src, args): cdef lo_server from_server cdef Address target_address cdef int r # convert target to Address object, if necessary if isinstance(target, Address): target_address = target elif isinstance(target, tuple): # unpack tuple target_address = Address(*target) else: target_address = Address(target) # 'from' parameter is NULL if no server was specified from_server = src._server if src else NULL if isinstance(args[0], (Message, Bundle)): # args is already a list of Messages/Bundles packets = args else: # make a single Message from all arguments packets = [Message(*args)] # send all packets for p in packets: if isinstance(p, Message): message = p r = lo_send_message_from(target_address._address, from_server, message._path, message._message) else: bundle = p r = lo_send_bundle_from(target_address._address, from_server, bundle._bundle) if r == -1: raise IOError("sending failed: %s" % lo_address_errstr(target_address._address)) def send(target, *args): """ Send a message without requiring a server The function has two forms: * `send(target, *messages)` * `send(target, path, *args)` Send messages to the the given target, without requiring a server. Arguments may be one or more `Message` or `Bundle` objects, or a single message given by its path and optional arguments. Args: target (Address | tuple[str, int] | int | str): the address to send the message to; an `Address` object, a port number, a `(hostname, port)` tuple, or a URL. path (str): the path of the message to be sent args (Any): the information to send. These are used to construct a message messages (Message | Bundle): one or more objects of type `Message` or `Bundle`. Raises: AddressError: if the given target is invalid IOError: if the message couldn't be sent. """ _send(target, None, args) ################################################################################ # Server ################################################################################ class ServerError(Exception): """ Raised when creating a liblo OSC server fails. """ def __init__(self, num, msg, where): self.num = num self.msg = msg self.where = where def __str__(self): s = "server error %d" % self.num if self.where: s += " in %s" % self.where s += ": %s" % self.msg return s cdef int _msg_callback(const_char *path, const_char *types, lo_arg **argv, int argc, lo_message msg, void *cb_data) noexcept with gil: cdef int i cdef char t cdef unsigned char *ptr cdef uint32_t size, j args = [] for i from 0 <= i < argc: t = types[i] if t == 'i': v = argv[i].i elif t == 'h': v = argv[i].h elif t == 'f': v = argv[i].f elif t == 'd': v = argv[i].d elif t == 'c': v = chr(argv[i].c) elif t == 's': v = _decode(&argv[i].s) elif t == 'S': v = _decode(&argv[i].s) elif t == 'T': v = True elif t == 'F': v = False elif t == 'N': v = None elif t == 'I': v = float('inf') elif t == 'm': v = (argv[i].m[0], argv[i].m[1], argv[i].m[2], argv[i].m[3]) elif t == 't': v = _timetag_to_double(argv[i].t) elif t == 'b': v = bytes(lo_blob_dataptr(argv[i])) else: v = None # unhandled data type args.append(v) cdef char *url = lo_address_get_url(lo_message_get_source(msg)) src = Address(url) free(url) cb = cb_data func_args = (_decode(path), args, _decode(types), src, cb.user_data) # call function # spec = _inspect.getfullargspec(func) if cb.has_varargs == 1: r = cb.func(*func_args) else: r = cb.func(*func_args[0:cb.numargs]) return r if r is not None else 0 cdef int _bundle_start_callback(lo_timetag t, void *cb_data) noexcept with gil: cb = cb_data r = cb.start_func(_timetag_to_double(t), cb.user_data) return r if r is not None else 0 cdef int _bundle_end_callback(void *cb_data) noexcept with gil: cb = cb_data r = cb.end_func(cb.user_data) return r if r is not None else 0 cdef void _err_handler(int num, const_char *msg, const_char *where) noexcept with gil: # can't raise exception in cdef callback function, so use a global variable # instead global __exception __exception = ServerError(num, msg, None) if where: __exception.where = where # decorator to register callbacks class make_method: """ A decorator that serves as a more convenient alternative to [Server.add_method](#add_method). Args: path (str | None): the message path to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. types (str): the argument types to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. user_data: An arbitrary object that will be passed on to the decorated method every time a matching message is received. """ # counter to keep track of the order in which the callback functions where # defined _counter = 0 def __init__(self, path, types, user_data=None): self.spec = struct(counter=make_method._counter, path=path, types=types, user_data=user_data) make_method._counter += 1 def __call__(self, f): # we can't access the Server object here, because at the time the # decorator is run it doesn't even exist yet, so we store the # path/typespec in the function object instead... if not hasattr(f, '_method_spec'): f._method_spec = [] f._method_spec.append(self.spec) return f # common base class for both Server and ServerThread cdef class _ServerBase: cdef lo_server _server cdef list _keep_refs def __init__(self, reg_methods=True): self._keep_refs = [] if reg_methods: self.register_methods() cdef _check(self): if self._server == NULL: raise RuntimeError("Server method called after free()") def register_methods(self, obj=None): """ Called internally during init if reg_methods is True Args: obj: The object that implements the OSC callbacks to be registered. By default this is the server object itself. This function is usually called automatically by the server's constructor, unless its *reg_methods* parameter was set to `False`. """ if obj == None: obj = self # find and register methods that were defined using decorators methods = [] for m in _inspect.getmembers(obj): if hasattr(m[1], '_method_spec'): for spec in m[1]._method_spec: methods.append(struct(spec=spec, name=m[1])) # sort by counter methods.sort(key=lambda x: x.spec.counter) for e in methods: self.add_method(e.spec.path, e.spec.types, e.name, e.spec.user_data) def get_url(self): """ Returns the url of the server Returns: (str) url of the server """ self._check() cdef char *tmp = lo_server_get_url(self._server) cdef object r = tmp free(tmp) return _decode(r) def get_port(self): """ Returns the port number of this server Returns: (int) port number """ self._check() return lo_server_get_port(self._server) def get_protocol(self): """ Returns the protocol of this server, as an int This will be one of `LO_TCP`, `LO_TCP` or `LO_UNIX` Returns: (int) the protocol as an int """ self._check() return lo_server_get_protocol(self._server) def fileno(self): """ Return the file descriptor of the server socket Returns: (int) the file descriptor, or -1 if not supported by the underlying server protocol """ self._check() return lo_server_get_socket_fd(self._server) def add_method(self, str path, str typespec, func, user_data=None): """ Register a callback for OSC messages with matching path and argument types. Args: path (str): the message path to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. typespec (str): the argument types to be handled by the registered method. `None` may be used as a wildcard to match any OSC message. func: the callback function. This may be a global function, a class method, or any other callable object, pyliblo will know what to do either way. user_data: An arbitrary object that will be passed on to *func* every time a matching message is received. """ cdef char *p cdef char *t if isinstance(path, (bytes, unicode)): s = _encode(path) p = s elif path is None: p = NULL else: raise TypeError("path must be a string or None") if isinstance(typespec, (bytes, unicode)): s2 = _encode(typespec) t = s2 elif typespec is None: t = NULL else: raise TypeError("typespec must be a string or None") self._check() # use a weak reference if func is a method, to avoid circular # references in cases where func is a method of an object that also # has a reference to the server (e.g. when deriving from the Server # class) # cb = struct(func=_weakref_method(func), user_data=user_data) cb = Callback(func, user_data) # keep a reference to the callback data around self._keep_refs.append(cb) lo_server_add_method(self._server, p, t, _msg_callback, cb) def del_method(self, path, typespec=None): """ Delete a callback function Delete a callback function. For both *path* and *typespec*, `None` may be used as a wildcard. Args: path (str | None): the method to delete typespec (str | None): the typespec to match, or None to delete any method matching the given path """ cdef char *p cdef char *t if isinstance(path, (bytes, unicode)): s = _encode(path) p = s elif path == None: p = NULL else: raise TypeError("path must be a string or None") if isinstance(typespec, (bytes, unicode)): s2 = _encode(typespec) t = s2 elif typespec == None: t = NULL else: raise TypeError("typespec must be a string or None") self._check() lo_server_del_method(self._server, p, t) def add_bundle_handlers(self, start_handler, end_handler, user_data=None): """ Add bundle notification handlers. Args: start_handler: a callback which fires when at the start of a bundle. This is called with the bundle's timestamp and user_data. end_handler: a callback which fires when at the end of a bundle. This is called with user_data. user_data: data to pass to the handlers. """ cb_data = struct(start_func=_weakref_method(start_handler), end_func=_weakref_method(end_handler), user_data=user_data) self._keep_refs.append(cb_data) lo_server_add_bundle_handlers(self._server, _bundle_start_callback, _bundle_end_callback, cb_data) def send(self, target, *args): """ Send a message or bundle from this server to the the given target. * `send(target, *messages)` * `send(target, path, *args)` Send a message or bundle from this server to the the given target. Arguments may be one or more `Message` or `Bundle` objects, or a single message given by its path and optional arguments. Args: target (Address | tuple[str, int] | str): the address to send the message to; an `Address` object, a port number, a `(hostname, port)` tuple, or a URL. messages (Message | Bundle): one or more objects of type `Message` or `Bundle`. path (str): the path of the message to be sent. Raises: AddressError: if the given target is invalid. IOError: if the message couldn't be sent. """ self._check() _send(target, self, args) property url: """ The server's URL. """ def __get__(self): return self.get_url() property port: """ The server's port number (int) """ def __get__(self): return self.get_port() property protocol: """ The server's protocol (one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX`). """ def __get__(self): return self.get_protocol() cdef class Server(_ServerBase): """ A server that can receive OSC messages, blocking Use [ServerThread](#ServerThread) for an OSC server that runs in its own thread and never blocks. Args: port (int | None): a decimal port number or a UNIX socket path. If omitted, an arbitrary free UDP port will be used. proto (int | str): one of LO_UDP, LO_TCP, LO_UNIX or LO_DEFAULT, or one of the strings 'UDP', 'TCP', 'UNIX' reg_methods (bool): if True, register any methods decorated with the [make_method](#make_method) decorator Raises: ServerError: if an error occurs created the underlying liblo server """ def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): cdef char *cs if port != None: p = _encode(str(port)); cs = p else: cs = NULL if isinstance(proto, str): proto = _protostr_to_int(proto) global __exception __exception = None self._server = lo_server_new_with_proto(cs, proto, _err_handler) if __exception: raise __exception _ServerBase.__init__(self, reg_methods=reg_methods) def __dealloc__(self): self.free() def free(self): """ Free the underlying server object and close its port. Note that this will also happen automatically when the server is deallocated. """ if self._server: lo_server_free(self._server) self._server = NULL def recv(self, timeout=None): """ Receive and dispatch one OSC message. Blocking by default, unless *timeout* is specified. Args: timeout (int, float): Time in milliseconds after which the function returns if no messages have been received. May be 0, in which case the function always returns immediately, whether messages have been received or not. Returns: (bool) `True` if a message was received, otherwise `False`. """ cdef int t, r self._check() if timeout != None: t = timeout with nogil: r = lo_server_recv_noblock(self._server, t) return r and True or False else: with nogil: lo_server_recv(self._server) return True cdef class ServerThread(_ServerBase): """ Server running in a thread Unlike `Server`, `ServerThread` uses its own thread which runs in the background to dispatch messages. `ServerThread` has the same methods as `Server`, with the exception of `.recv`. Instead, it defines two additional methods `.start` and `.stop`. Args: port (int | str): a decimal port number or a UNIX socket path. If omitted, an arbitrary free UDP port will be used. proto (int | str): one of the constants `LO_UDP`, `LO_TCP` or `LO_UNIX` or a corresponding string 'UDP', 'TCP', 'UNIX' reg_methods: if True, register any method decorated with the [make_method](#make_method) decorator Raises: ServerError: if creating the server fails, e.g. because the given port could not be opened. !!! note Because liblo creates its own thread to receive and dispatch messages, callback functions will not be run in the main Python thread! """ cdef lo_server_thread _server_thread def __init__(self, port=None, proto=LO_DEFAULT, reg_methods=True): cdef char *cs if port != None: p = _encode(str(port)); cs = p else: cs = NULL # make sure python can handle threading PyEval_InitThreads() global __exception __exception = None self._server_thread = lo_server_thread_new_with_proto(cs, proto, _err_handler) if __exception: raise __exception self._server = lo_server_thread_get_server(self._server_thread) _ServerBase.__init__(self, reg_methods=reg_methods) def __dealloc__(self): self.free() def free(self): """ Free the underlying server object and close its port. !!! note This method is called automatically when the server is deallocated. """ if self._server_thread: lo_server_thread_free(self._server_thread) self._server_thread = NULL self._server = NULL def start(self): """ Start the server thread. liblo will now start to dispatch any messages it receives. """ self._check() lo_server_thread_start(self._server_thread) def stop(self): """ Stop the server thread. """ self._check() lo_server_thread_stop(self._server_thread) ################################################################################ # Address ################################################################################ class AddressError(Exception): """ Raised when trying to create an invalid `Address` object. """ def __init__(self, msg): self.msg = msg def __str__(self): return "address error: %s" % self.msg cdef class Address: """ An Address represents a destination for a message Possible forms: * `Address(hostname: str, port: int, proto: [int | str] = LO_UDP`) * `Address(port: int)` # Assumes localhost * `Address(url: str)` # A URL of the form 'osc.udp://hostname:1234/' Create a new `Address` object from the given hostname/port or URL. Args: hostname: the target's hostname - the name or an IP of the form '127.0.0.0'. port: the port number of the target proto: one of the constants `LO_UDP`, `LO_TCP`, `LO_UNIX` or a string like 'UDP', 'TCP' or 'UNIX' url: a URL in liblo notation, e.g. `'osc.udp://hostname:1234/'`. Raises: AddressError: if the given parameters do not represent a valid address. """ cdef lo_address _address def __init__(self, addr, addr2=None, proto=LO_UDP): if isinstance(proto, str): proto = _protostr_to_int(proto) if addr2: # Address(host, port[, proto]) s = _encode(addr) s2 = _encode(str(addr2)) self._address = lo_address_new_with_proto(proto, s, s2) if not self._address: raise AddressError("invalid protocol") elif isinstance(addr, int) or (isinstance(addr, str) and addr.isdigit()): # Address(port) s = str(addr).encode() self._address = lo_address_new(NULL, s) else: # Address(url) s = _encode(addr) self._address = lo_address_new_from_url(s) # lo_address_errno() is of no use if self._addr == NULL if not self._address: raise AddressError("invalid URL '%s'" % str(addr)) def __dealloc__(self): lo_address_free(self._address) def get_url(self): """This Address as a liblo URL""" cdef char *tmp = lo_address_get_url(self._address) cdef object r = tmp free(tmp) return _decode(r) def get_hostname(self): """The hostname of this Address""" return _decode(lo_address_get_hostname(self._address)) def get_port(self): """The port number of this Address""" cdef bytes s = lo_address_get_port(self._address) if s.isdigit(): return int(s) else: return _decode(s) def get_protocol(self): """ The protocol used as an int Example ------- ```python from pyliblo3 import * address = Address('127.0.0.0', 9876) assert address.get_protocol() == LO_UDP ``` """ return lo_address_get_protocol(self._address) property url: """ The address's URL. """ def __get__(self): return self.get_url() property hostname: """ The address's hostname. """ def __get__(self): return self.get_hostname() property port: """ The address's port number. """ def __get__(self): return self.get_port() property protocol: """ The address's protocol (one of the constants :const:`UDP`, :const:`TCP`, or :const:`UNIX`). """ def __get__(self): return self.get_protocol() ################################################################################ # Message ################################################################################ cdef class _Blob: cdef lo_blob _blob def __init__(self, arr): # arr can by any sequence type cdef unsigned char *p cdef uint32_t size, i size = len(arr) if size < 1: raise ValueError("blob is empty") # copy each element of arr to a C array p = malloc(size) try: if isinstance(arr[0], (str, unicode)): # use ord() if arr is a string (but not bytes) for i from 0 <= i < size: p[i] = ord(arr[i]) else: for i from 0 <= i < size: p[i] = arr[i] # build blob self._blob = lo_blob_new(size, p) finally: free(p) def __dealloc__(self): lo_blob_free(self._blob) cdef class Message: """ An OSC message, consisting of a path and arbitrary arguments. Args: path (str): the path of the message args: any arguments passed will be added to this messag """ cdef bytes _path cdef lo_message _message cdef list _keep_refs def __init__(self, path, *args): self._keep_refs = [] # encode path to bytestring if necessary self._path = _encode(path) self._message = lo_message_new() self.add(*args) def __dealloc__(self): lo_message_free(self._message) def add(self, *args): """ Append the given arguments to this message Arguments can be single values or `(typetag, data)` tuples to specify the actual type. This might be needed for numbers, to specify if a float needs to be encoded as a 32-bit (typetag = 'f') or 64-bit float (typetag = 'd'). By default, float numbers are interpreted as 32-bit floats. Args: args: each argument can be a single value or a tuple `(typetag: str, data: Any)` """ for arg in args: if (isinstance(arg, tuple) and len(arg) <= 2 and isinstance(arg[0], (bytes, unicode)) and len(arg[0]) == 1): # type explicitly specified if len(arg) == 2: self._add(arg[0], arg[1]) else: self._add(arg[0], None) else: # detect type automatically self._add_auto(arg) cdef _add(self, type, value): cdef uint8_t midi[4] # accept both bytes and unicode as type specifier cdef char t = ord(_decode(type)[0]) if t == 'i': lo_message_add_int32(self._message, int(value)) elif t == 'h': lo_message_add_int64(self._message, long(value)) elif t == 'f': lo_message_add_float(self._message, float(value)) elif t == 'd': lo_message_add_double(self._message, float(value)) elif t == 'c': lo_message_add_char(self._message, ord(value)) elif t == 's': s = _encode(value) lo_message_add_string(self._message, s) elif t == 'S': s = _encode(value) lo_message_add_symbol(self._message, s) elif t == 'T': lo_message_add_true(self._message) elif t == 'F': lo_message_add_false(self._message) elif t == 'N': lo_message_add_nil(self._message) elif t == 'I': lo_message_add_infinitum(self._message) elif t == 'm': for n from 0 <= n < 4: midi[n] = value[n] lo_message_add_midi(self._message, midi) elif t == 't': lo_message_add_timetag(self._message, _double_to_timetag(value)) elif t == 'b': b = _Blob(value) # make sure the blob is not deleted as long as this message exists self._keep_refs.append(b) lo_message_add_blob(self._message, (<_Blob>b)._blob) else: raise TypeError("unknown OSC data type '%c'" % t) cdef _add_auto(self, value): # bool is a subclass of int, so check those first if value is True: lo_message_add_true(self._message) elif value is False: lo_message_add_false(self._message) elif isinstance(value, (int, long)): try: lo_message_add_int32(self._message, value) except OverflowError: lo_message_add_int64(self._message, value) elif isinstance(value, float): lo_message_add_float(self._message, float(value)) elif isinstance(value, (bytes, unicode)): s = _encode(value) lo_message_add_string(self._message, s) elif value == None: lo_message_add_nil(self._message) elif value == float('inf'): lo_message_add_infinitum(self._message) else: # last chance: could be a blob try: iter(value) except TypeError: raise TypeError("unsupported message argument type") self._add('b', value) ################################################################################ # Bundle ################################################################################ cdef class Bundle: """ A bundle of one or more messages to be sent and dispatched together. Possible forms: * `Bundle(*messages)` * `Bundle(timetag: float, *messages)` Create a new `Bundle` object. You can optionally specify a time at which the messages should be dispatched (as an OSC timetag float), and any number of messages to be included in the bundle. Args: timetag (float): optional, speficies the time at which the message should be dispatched messages: any number of `Message`s to include in this `Bundle` """ cdef lo_bundle _bundle cdef list _keep_refs def __init__(self, *messages): cdef lo_timetag tt tt.sec, tt.frac = 0, 0 self._keep_refs = [] if len(messages) and not isinstance(messages[0], Message): t = messages[0] if isinstance(t, (float, int, long)): tt = _double_to_timetag(t) elif isinstance(t, tuple) and len(t) == 2: tt.sec, tt.frac = t else: raise TypeError("invalid timetag") # first argument was timetag, so continue with second messages = messages[1:] self._bundle = lo_bundle_new(tt) if len(messages): self.add(*messages) def __dealloc__(self): lo_bundle_free(self._bundle) def add(self, *args): """ Add one or more messages to this bundle Possible forms: * `add(*messages: Message)` * `add(path: str, *args)`, where path is the osc path (for example, '/path1' or '/root/subpath') and `args` are passed directly to `Message` to create a Message to be added to this Bundle Add one or more messages to the bundle. Args: args: either a Message or a set or arguments passed directly to `Message` to create a `Message` which is added to this `Bundle` """ if isinstance(args[0], Message): # args is already a list of Messages messages = args else: # make a single Message from all arguments messages = [Message(*args)] # add all messages for m in messages: self._keep_refs.append(m) message = m lo_bundle_add_message(self._bundle, message._path, message._message) pyliblo3-master/pyproject.toml000066400000000000000000000001761465273517200170400ustar00rootroot00000000000000[build-system] requires = [ "setuptools>=42", "wheel", "cython>=3.0" ] build-backend = "setuptools.build_meta" pyliblo3-master/readthedocs.yml000066400000000000000000000006421465273517200171320ustar00rootroot00000000000000# .readthedocs.yml # Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details # Required version: 2 # Optionally build your docs in additional formats such as PDF # formats: # - pdf build: os: ubuntu-22.04 tools: python: "3.11" python: install: - requirements: docs/requirements.txt # setup_py_install: true mkdocs: configuration: mkdocs.yml pyliblo3-master/scripts/000077500000000000000000000000001465273517200156075ustar00rootroot00000000000000pyliblo3-master/scripts/dump_osc.1000066400000000000000000000005011465273517200174760ustar00rootroot00000000000000.TH dump_osc 1 .SH NAME dump_osc \- Prints incoming OSC messages .SH SYNOPSIS .B dump_osc \fIport\fP .SH DESCRIPTION .B dump_osc prints all OSC messages received on \fIport\fP (UDP port number, or any other address string supported by liblo). .SH AUTHOR Dominic Sacre .SH SEE ALSO send_osc(1) pyliblo3-master/scripts/dump_osc.py000077500000000000000000000041351465273517200200000ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # pyliblo - Python bindings for the liblo OSC library # # Copyright (C) 2007-2011 Dominic Sacré # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # import sys import pyliblo3 as liblo class DumpOSC: def blob_to_hex(self, b): return " ".join([ (hex(v/16).upper()[-1] + hex(v%16).upper()[-1]) for v in b ]) def callback(self, path, args, types, src): write = sys.stdout.write ## print source #write("from " + src.get_url() + ": ") # print path write(path + " ,") # print typespec write(types) # loop through arguments and print them for a, t in zip(args, types): write(" ") if t == None: #unknown type write("[unknown type]") elif t == 'b': # it's a blob write("[" + self.blob_to_hex(a) + "]") else: # anything else write(str(a)) write('\n') def __init__(self, port = None): # create server object try: self.server = liblo.Server(port) except liblo.ServerError as err: sys.exit(str(err)) print("listening on URL: " + self.server.get_url()) # register callback function for all messages self.server.add_method(None, None, self.callback) def run(self): # just loop and dispatch messages every 10ms while True: self.server.recv(10) if __name__ == '__main__': # display help if len(sys.argv) == 1 or sys.argv[1] in ("-h", "--help"): sys.exit("Usage: " + sys.argv[0] + " port") # require one argument (port number) if len(sys.argv) < 2: sys.exit("please specify a port or URL") app = DumpOSC(sys.argv[1]) try: app.run() except KeyboardInterrupt: del app pyliblo3-master/scripts/send_osc.1000066400000000000000000000013331465273517200174660ustar00rootroot00000000000000.TH send_osc 1 .SH NAME send_osc \- Sends a single OSC message .SH SYNOPSIS .B send_osc \fIport\fP \fIpath\fP [,\fItypes\fP] [\fIargs\fP...] .SH DESCRIPTION .B send_osc sends an OSC message to the specified \fIport\fP (UDP port number, or any other address string supported by liblo). The message is delivered to \fIpath\fP. If the first argument following the path starts with a comma, it's interpreted as a type string, specifying the OSC data types to be used for sending the message arguments. Otherwise, send_osc automatically tries to use appropriate data types. Valid integer and float values are sent as such, anything else is sent as a string. .SH AUTHOR Dominic Sacre .SH SEE ALSO dump_osc(1) pyliblo3-master/scripts/send_osc.py000077500000000000000000000033611465273517200177640ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # pyliblo - Python bindings for the liblo OSC library # # Copyright (C) 2007-2011 Dominic Sacré # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # import sys import pyliblo3 as liblo def make_message_auto(path, *args): msg = liblo.Message(path) for a in args: try: v = int(a) except ValueError: try: v = float(a) except ValueError: v = a msg.add(v) return msg def make_message_manual(path, types, *args): if len(types) != len(args): sys.exit("length of type string doesn't match number of arguments") msg = liblo.Message(path) try: for a, t in zip(args, types): msg.add((t, a)) except Exception as e: sys.exit(str(e)) return msg if __name__ == '__main__': # display help if len(sys.argv) == 1 or sys.argv[1] in ("-h", "--help"): sys.exit("Usage: " + sys.argv[0] + " port path [,types] [args...]") # require at least two arguments (target port/url and message path) if len(sys.argv) < 2: sys.exit("please specify a port or URL") if len(sys.argv) < 3: sys.exit("please specify a message path") if len(sys.argv) > 3 and sys.argv[3].startswith(','): msg = make_message_manual(sys.argv[2], sys.argv[3][1:], *sys.argv[4:]) else: msg = make_message_auto(*sys.argv[2:]) try: liblo.send(sys.argv[1], msg) except IOError as e: sys.exit(str(e)) else: sys.exit(0) pyliblo3-master/setup.py000077500000000000000000000060521465273517200156400ustar00rootroot00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- from setuptools import setup, Extension import platform import glob import os import shutil import subprocess VERSION = '0.16.2' platformname = platform.system() include_dirs = ["pyliblo3"] library_dirs = [] libraries = [] compile_args = [] def append_if_exists(lst: list[str], path: str) -> None: if os.path.exists(path): if path not in lst: lst.append(path) print(f"~~~~~ Added path: {path}") else: print(f"***** Path does not exists, skipping: '{path}'") if platformname == 'Darwin': libraries.append('lo') brewpath = shutil.which("brew") if brewpath: brewprefix = subprocess.getoutput("brew --prefix") append_if_exists(include_dirs, brewprefix + "/include") append_if_exists(library_dirs, brewprefix + "/lib") include_dirs.append("/usr/local/include/") append_if_exists(include_dirs, "/opt/local/include/") library_dirs.append("/usr/local/lib") append_if_exists(library_dirs, "/opt/local/lib") compile_args += [ '-fno-strict-aliasing', '-Werror-implicit-function-declaration', '-Wfatal-errors' ] elif platformname == 'Linux': libraries.append('lo') include_dirs.extend(['/usr/include', '/usr/local/include']) library_dirs.append("/usr/local/lib") compile_args += [ '-fno-strict-aliasing', '-Werror-implicit-function-declaration', '-Wfatal-errors' ] elif platformname == "Windows": libraries.append('liblo') # Default install directory for liblo built from source # See also the wheel build script where we add the .../lib and .../bin # directories so that the wheel repair script can find the liblo dll # to add it to the wheel. When building from source, the user needs # to install liblo and add its lib and bin directories to the path append_if_exists(include_dirs, "C:/Program Files/liblo/include") append_if_exists(library_dirs, "C:/Program Files/liblo/lib") else: pass # read the contents of your README file thisdir = os.path.abspath(os.path.dirname(__file__)) with open(os.path.join(thisdir, 'README.md')) as f: long_description = f.read() setup( name='pyliblo3', python_requires='>=3.9', version=VERSION, scripts=glob.glob("scripts/*.py"), ext_modules=[ Extension( 'pyliblo3._liblo', #sources = ['src/liblo.pyx', 'src/liblo.pxd'], sources = ['pyliblo3/_liblo.pyx'], extra_compile_args=compile_args, libraries=libraries, library_dirs=library_dirs, include_dirs=include_dirs) ], packages=['pyliblo3'], author='Dominic Sacre', author_email='dominic.sacre@gmx.de', maintainer='Eduardo Moguillansky', maintainer_email='eduardo.moguillansky@gmail.com', url='https://github.com/gesellkammer/pyliblo3', description='Python bindings for the liblo OSC library', long_description=long_description, long_description_content_type='text/markdown', license='LGPL', ) pyliblo3-master/test/000077500000000000000000000000001465273517200150775ustar00rootroot00000000000000pyliblo3-master/test/unit.py000077500000000000000000000220021465273517200164270ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # pyliblo - Python bindings for the liblo OSC library # # Copyright (C) 2007-2011 Dominic Sacré # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # import unittest import re import time import sys import pyliblo3 as liblo import platform portnum = 9876 def approx(a, b, e = 0.0002): return abs(a - b) < e def matchHost(host, regex): r = re.compile(regex) return r.match(host) != None class Arguments: def __init__(self, path, args, types, src, data): self.path = path self.args = args self.types = types self.src = src self.data = data class ServerTestCaseBase(unittest.TestCase): def setUp(self): self.cb = None def callback(self, path, args, types, src, data): self.cb = Arguments(path, args, types, src, data) def callback_dict(self, path, args, types, src, data): if self.cb == None: self.cb = { } self.cb[path] = Arguments(path, args, types, src, data) class ServerTestCase(ServerTestCaseBase): def setUp(self): ServerTestCaseBase.setUp(self) self.server = liblo.Server(str(portnum)) def tearDown(self): del self.server def testPort(self): assert self.server.get_port() == portnum def testURL(self): assert matchHost(self.server.get_url(), fr'osc\.udp://.*:{portnum}/') def testSendInt(self): self.server.add_method('/foo', 'i', self.callback, "data") self.server.send(str(portnum), '/foo', 123) assert self.server.recv() == True assert self.cb.path == '/foo' assert self.cb.args[0] == 123 assert self.cb.types == 'i' assert self.cb.data == ("data",) assert matchHost(self.cb.src.get_url(), fr'osc\.udp://.*:{portnum}/') def testSendBlob(self): self.server.add_method('/blob', 'b', self.callback) self.server.send(str(portnum), '/blob', [4, 8, 15, 16, 23, 42]) assert self.server.recv() == True if sys.hexversion < 0x03000000: assert list(self.cb.args[0]) == [4, 8, 15, 16, 23, 42] else: assert self.cb.args[0] == b'\x04\x08\x0f\x10\x17\x2a' def testSendVarious(self): self.server.add_method('/blah', 'ihfdscb', self.callback) if sys.hexversion < 0x03000000: self.server.send(portnum, '/blah', 123, 2**42, 123.456, 666.666, "hello", ('c', 'x'), (12, 34, 56)) else: self.server.send(portnum, '/blah', 123, ('h', 2**42), 123.456, 666.666, "hello", ('c', 'x'), (12, 34, 56)) assert self.server.recv() == True assert self.cb.types == 'ihfdscb' assert len(self.cb.args) == len(self.cb.types) assert self.cb.args[0] == 123 assert self.cb.args[1] == 2**42 assert approx(self.cb.args[2], 123.456) assert approx(self.cb.args[3], 666.666) assert self.cb.args[4] == "hello" assert self.cb.args[5] == 'x' if sys.hexversion < 0x03000000: assert list(self.cb.args[6]) == [12, 34, 56] else: assert self.cb.args[6] == b'\x0c\x22\x38' def testSendOthers(self): self.server.add_method('/blubb', 'tmSTFNI', self.callback) self.server.send(portnum, '/blubb', ('t', 666666.666), ('m', (1, 2, 3, 4)), ('S', 'foo'), True, ('F',), None, ('I',)) assert self.server.recv() == True assert self.cb.types == 'tmSTFNI' assert approx(self.cb.args[0], 666666.666) assert self.cb.args[1] == (1, 2, 3, 4) assert self.cb.args[2] == 'foo' assert self.cb.args[3] == True assert self.cb.args[4] == False assert self.cb.args[5] == None assert self.cb.args[6] == float('inf') def testSendMessage(self): self.server.add_method('/blah', 'is', self.callback) m = liblo.Message('/blah', 42, 'foo') self.server.send(portnum, m) assert self.server.recv() == True assert self.cb.types == 'is' assert self.cb.args[0] == 42 assert self.cb.args[1] == 'foo' def testSendBundle(self): self.server.add_method('/foo', 'i', self.callback_dict) self.server.add_method('/bar', 's', self.callback_dict) self.server.send(portnum, liblo.Bundle( liblo.Message('/foo', 123), liblo.Message('/bar', "blubb") )) assert self.server.recv(100) == True assert self.cb['/foo'].args[0] == 123 assert self.cb['/bar'].args[0] == "blubb" def testSendTimestamped(self): self.server.add_method('/blubb', 'i', self.callback) d = 1.23 t1 = time.time() b = liblo.Bundle(liblo.time() + d) b.add('/blubb', 42) self.server.send(portnum, b) while not self.cb: self.server.recv(1) t2 = time.time() assert approx(t2 - t1, d, 0.01) def testSendInvalid(self): try: self.server.send(portnum, '/blubb', ('x', 'y')) except TypeError as e: pass else: assert False def testRecvTimeout(self): t1 = time.time() assert self.server.recv(500) == False t2 = time.time() assert t2 - t1 < 0.666 def testRecvImmediate(self): t1 = time.time() assert self.server.recv(0) == False t2 = time.time() assert t2 - t1 < 0.01 class ServerCreationTestCase(unittest.TestCase): def testNoPermission(self): try: s = liblo.Server('22') except liblo.ServerError as e: pass except OSError as e: # On macos this test fails with OSError: nodename nor servname provided, or not known # And it should in fact fail if platform.system() == 'Darwin': pass else: assert False else: assert False def testRandomPort(self): s = liblo.Server() assert 1024 <= s.get_port() <= 65535 def testPort(self): s = liblo.Server(1234) t = liblo.Server('5678') assert s.port == 1234 assert t.port == 5678 assert matchHost(s.url, r'osc\.udp://.*:1234/') def testPortProto(self): s = liblo.Server(1234, liblo.TCP) assert matchHost(s.url, r'osc\.tcp://.*:1234/') class ServerTCPTestCase(ServerTestCaseBase): def setUp(self): ServerTestCaseBase.setUp(self) self.server = liblo.Server('1234', liblo.TCP) def tearDown(self): del self.server def testSendReceive(self): self.server.add_method('/foo', 'i', self.callback) liblo.send(self.server.url, '/foo', 123) assert self.server.recv() == True assert self.cb.path == '/foo' assert self.cb.args[0] == 123 assert self.cb.types == 'i' #def testNotReachable(self): # try: # self.server.send('osc.tcp://192.168.23.42:4711', '/foo', 23, 42) # except IOError: # pass # else: # assert False class ServerThreadTestCase(ServerTestCaseBase): def setUp(self): ServerTestCaseBase.setUp(self) self.server = liblo.ServerThread('1234') def tearDown(self): del self.server def testSendAndReceive(self): self.server.add_method('/foo', 'i', self.callback) self.server.send('1234', '/foo', 42) self.server.start() time.sleep(0.2) self.server.stop() assert self.cb.args[0] == 42 class DecoratorTestCase(unittest.TestCase): class TestServer(liblo.Server): def __init__(self): liblo.Server.__init__(self, portnum) @liblo.make_method('/foo', 'ibm') def foo_cb(self, path, args, types, src, data): self.cb = Arguments(path, args, types, src, data) def setUp(self): self.server = self.TestServer() def tearDown(self): del self.server def testSendReceive(self): liblo.send(portnum, '/foo', 42, ('b', [4, 8, 15, 16, 23, 42]), ('m', (6, 6, 6, 0))) assert self.server.recv() == True assert self.server.cb.path == '/foo' assert len(self.server.cb.args) == 3 class AddressTestCase(unittest.TestCase): def testPort(self): a = liblo.Address(1234) b = liblo.Address('5678') assert a.port == 1234 assert b.port == 5678 assert a.url == 'osc.udp://localhost:1234/' def testUrl(self): a = liblo.Address('osc.udp://foo:1234/') assert a.url == 'osc.udp://foo:1234/' assert a.hostname == 'foo' assert a.port == 1234 assert a.protocol == liblo.UDP def testHostPort(self): a = liblo.Address('foo', 1234) assert a.url == 'osc.udp://foo:1234/' def testHostPortProto(self): a = liblo.Address('foo', 1234, liblo.TCP) assert a.url == 'osc.tcp://foo:1234/' if __name__ == "__main__": unittest.main() pyliblo3-master/test/unit.py.patch000077500000000000000000000004101465273517200175240ustar00rootroot0000000000000079c79 < assert list(self.cb.args[0]) == [4, 8, 15, 16, 23, 42] --- > assert self.cb.args[0] == [4, 8, 15, 16, 23, 42] 99c99 < assert list(self.cb.args[6]) == [12, 34, 56] --- > assert self.cb.args[6] == [12, 34, 56]