Anonymous avatar Anonymous committed 3cc60d8

initial import of pyliblo 0.8.1

Comments (0)

Files changed (13)

+		  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.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
+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.
+Metadata-Version: 1.0
+Name: pyliblo
+Version: 0.8.1
+Summary: Python bindings for the liblo OSC library
+Home-page: http://das.nasophon.de/pyliblo/
+Author: Dominic Sacre
+Author-email: dominic.sacre@gmx.de
+License: LGPL
+Description: UNKNOWN
+Platform: UNKNOWN
+pyliblo - Python bindings for the liblo OSC library
+
+Copyright (C) 2007-2009  Dominic Sacré  <dominic.sacre@gmx.de>
+
+http://das.nasophon.de/pyliblo/
+
+
+To install, run "./setup.py build", followed by "./setup.py install". This
+will install both the python module and the send_osc/dump_osc scripts.
+
+The C source file generated by Pyrex is included in the distribution, so
+it's not necessary to have Pyrex installed in order to build pyliblo.
+To build from the original Pyrex source anyway, remove src/liblo.c, then
+pass '--with-pyrex' to setup.py. To use Cython instead of Pyrex, pass
+'--with-cython' to setup.py.
+
+
+See doc/API.html and doc/examples.html for API documentation and some
+example code.
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang="en">
+
+<head>
+  <title>pyliblo - API Documentation</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+  <style type="text/css">
+    body { max-width: 60em; font-size: 90%; font-family: sans-serif; }
+    h1 { font-size: 130%; color: #333; background: #eee; padding: 4px 0.7em; }
+    h2 { font-size: 110%; color: #fff; background: #667; padding: 4px 0.7em; margin-top: 1.5em; }
+    h3 { font-size: 100%; color: #333; padding-left: 0.5em; margin-bottom: 0.4em; }
+    p,table,pre { margin-left: 0.8em; margin-top: 0.4em; }
+    b { color: #333; }
+    pre { font-size: 110%; }
+    table { border: 1px solid #333; border-collapse: collapse; }
+    th, td { border: 1px solid #333; padding: 0em 0.3em; }
+    th { color: #333; text-align: left; background: #eee; }
+  </style>
+</head>
+
+<body>
+
+<h1>pyliblo 0.8 - API Documentation</h1>
+
+<p>
+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
+<a href="http://liblo.sourceforge.net/docs/modules.html">liblo documentation</a>.
+</p>
+
+<p>
+The Python module is simply called <b>liblo</b>.
+</p>
+
+
+<h2>functions</h2>
+
+<h3>send(target, message)<br>
+send(target, bundle)<br>
+send(target, path[, arg, ...])</h3>
+<p>
+Sends a message or bundle to the the given target, without requiring a server.<br>
+target may be an <b>Address</b> object, a port number, a (hostname, port) tuple, or a URL.<br>
+Exceptions: <b>AddressError</b>
+</p>
+
+<h3>time()</h3>
+<p>
+Returns the current time as a float in OSC format, that is, the number of seconds since
+the epoch (January 1, 1900).
+</p>
+
+
+<h2>class Server</h2>
+
+<h3>Server([port[, proto[, **kwargs]]])</h3>
+<p>
+Creates a new <b>Server</b> object, which can receive OSC messages.<br>
+port may be a decimal port number or a UNIX socket path.
+If omitted, an arbitrary free UDP port will be used.<br>
+proto can be one of the constants UDP, TCP, UNIX.<br>
+Optional keyword arguments:<br>
+<b>reg_methods</b>: False if you don't want the init function to automatically
+register callbacks defined with the @make_method decorator.<br>
+Exceptions: <b>ServerError</b>
+</p>
+
+<h3>add_method(path, typespec, callback_func[, user_data])</h3>
+<p>
+Registers a callback function for OSC messages with matching path and argument types.<br>
+For both path and typespec, None may be used as a wildcard.<br>
+The optional user_data will be passed on to the callback function.
+callback_func may be a global function or a class method, pyliblo will know what to do either way.
+</p>
+
+<h3>@make_method(path, typespec[, user_data])</h3>
+<p>
+Decorator function that basically serves the same purpose as add_method().
+Decorators require Python 2.4 or later.<br>
+Note that @make_method is defined at module scope, and not a member of class Server.
+</p>
+
+<h3>register_methods([obj])</h3>
+<p>
+Calls add_method() for all methods of obj decorated with @make_method. obj defaults to
+the Server object itself.<br>
+This function is called automatically by the Server's init function, unless its reg_methods
+parameter is False.
+</p>
+
+<h3>my_callback(path, args[, types[, src[, user_data]]])<br>
+my_callback(self, path, args[, types[, src[, user_data]]])</h3>
+<p>
+User-defined callback function, to be registered using add_method() or @make_method;
+called when a matching OSC message is received.<br>
+args will be a list of message arguments, using appropriate built-in Python data types.
+types is a string with the typespec of the message.
+src is an <b>Address</b> object, containing the address the message came from.
+types, src and user_data may be omitted if not needed.<br>
+The callback should return zero (or nothing/None) if the message has been dealt with correctly,
+or non-zero to look for another matching message handler.
+</p>
+
+<h3>recv([timeout])</h3>
+<p>
+Receives and dispatches one OSC message.
+Blocking by default, unless timeout (in ms) is specified.<br>
+timeout may be 0, in which case recv() returns immediately.
+Returns True if a message was received, False otherwise.
+</p>
+
+<h3>send(target, message)<br>
+send(target, bundle)<br>
+send(target, path[, arg, ...])</h3>
+<p>
+Sends a message or bundle from this server to the the given target.<br>
+target may be an <b>Address</b> object, a port number, a (hostname, port) tuple, or a URL.<br>
+Exceptions: <b>AddressError</b>
+</p>
+
+<h3>get_url()</h3>
+<p>
+Returns the server's URL.
+</p>
+
+<h3>get_port()</h3>
+<p>
+Returns the server's port number.
+</p>
+
+<h3>get_protocol()</h3>
+<p>
+Returns the server's protocol (one of the constants UDP, TCP, UNIX).
+</p>
+
+
+<h2>class ServerThread</h2>
+<p>
+Unlike <b>Server</b>, <b>ServerThread</b> uses its own thread which runs in the background
+to dispatch messages. Note that callback methods will not be run in the main Python thread!<br>
+<b>ServerThread</b> has the same methods as <b>Server</b>, with the exception of recv().
+Instead, it defines these two methods:
+</p>
+
+<h3>start()</h3>
+<p>
+Starts the server thread, liblo will now start to dispatch any messages it receives.
+</p>
+
+<h3>stop()</h3>
+<p>
+Stops the server thread.
+</p>
+
+
+<h2>class Address</h2>
+
+<h3>Address(hostname, port)<br>
+Address(port)<br>
+Address(url)</h3>
+<p>
+Creates a new <b>Address</b> object from the given hostname/port or URL.<br>
+Exceptions: <b>AddressError</b>
+</p>
+
+<h3>get_url()</h3>
+<p>
+Returns the address' URL.
+</p>
+
+<h3>get_hostname()</h3>
+<p>
+Returns the address' hostname.
+</p>
+
+<h3>get_port()</h3>
+<p>
+Returns the address' port number.
+</p>
+
+<h3>get_protocol()</h3>
+<p>
+Returns the address' protocol (one of the constants UDP, TCP, UNIX).
+</p>
+
+
+<h2>class Message</h2>
+
+<h3>Message(path[, arg, ...])</h3>
+<p>
+Creates a new <b>Message</b> object.
+</p>
+
+<h3>add(arg[, ...])</h3>
+<p>
+Appends the given argument(s) to the message.
+</p>
+
+
+<h2>class Bundle</h2>
+
+<h3>Bundle([timetag, ][message, ...])</h3>
+<p>
+Creates a new <b>Bundle</b> 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.<br>
+</p>
+
+<h3>add(message[, ...])<br>
+add(path[, arg, ...])</h3>
+<p>
+Adds one or more messages to the bundle.
+</p>
+
+<h2>mapping between OSC and Python data types</h2>
+<p>
+When constructing a message, pyliblo tries to automatically convert arguments to an appropriate
+OSC data type, depending on the Python argument.
+To explicitly specify the OSC data type to be transmitted, pass a (typetag, data) tuple.
+Some types can't be unambiguously recognized, so they can only be sent that way.<br>
+Callback functions always receive their arguments according to the following table:
+</p>
+<table border="1">
+  <tr><th>typetag</th><th>OSC data type</th><th>Python data type</th></tr>
+  <tr><td>'i'</td><td>int32</td><td>int</td></tr>
+  <tr><td>'h'</td><td>int64</td><td>long</td></tr>
+  <tr><td>'f'</td><td>float</td><td>float</td></tr>
+  <tr><td>'d'</td><td>double</td><td>float</td></tr>
+  <tr><td>'c'</td><td>char</td><td>single-character string</td></tr>
+  <tr><td>'s'</td><td>string</td><td>string</td></tr>
+  <tr><td>'S'</td><td>symbol</td><td>string</td></tr>
+  <tr><td>'m'</td><td>midi</td><td>4-tuple of ints</td></tr>
+  <tr><td>'t'</td><td>timetag</td><td>float</td></tr>
+  <tr><td>'T'</td><td>true</td><td>-</td></tr>
+  <tr><td>'F'</td><td>false</td><td>-</td></tr>
+  <tr><td>'N'</td><td>nil</td><td>-</td></tr>
+  <tr><td>'I'</td><td>infinitum</td><td>-</td></tr>
+  <tr><td>'b'</td><td>blob</td><td>list of ints</td></tr>
+</table>
+
+</body>
+
+</html>

doc/examples.html

+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang="en">
+
+<head>
+  <title>pyliblo - Example Code</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+  <style type="text/css">
+    body { max-width: 60em; font-size: 90%; font-family: sans-serif; }
+    h1 { font-size: 130%; color: #333; background: #eee; padding: 4px 0.7em; }
+    h2 { font-size: 110%; color: #fff; background: #667; padding: 4px 0.7em; margin-top: 1.5em; }
+    h3 { font-size: 100%; color: #333; padding-left: 0.5em; margin-bottom: 0.4em; }
+    p,table,pre { margin-left: 0.8em; margin-top: 0.4em; }
+    b { color: #333; }
+    th { color: #333; text-align: left; background: #eee; }
+    pre { font-size: 110%; }
+  </style>
+</head>
+
+<body>
+
+<h1>pyliblo - Example Code</h1>
+
+<p>
+Just some useless code to show what you can do with pyliblo.
+</p>
+<p>
+Also take a look at the send_osc and dump_osc scripts, for tiny but functional examples.
+</p>
+
+<h2>Example Client</h2>
+
+<pre>
+#!/usr/bin/env python
+
+import liblo, sys
+
+# send all messages to port 1234 on the local machine
+try:
+    target = liblo.Address(1234)
+except liblo.AddressError, err:
+    print str(err)
+    sys.exit()
+
+# send message "/foo/message1" with int, float and string arguments
+liblo.send(target, "/foo/message1", 123, 456.789, "test")
+
+# 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)
+</pre>
+
+<h2>Example Server</h2>
+
+<pre>
+#!/usr/bin/env python
+
+import liblo, sys
+
+# create server, listening on port 1234
+try:
+    server = liblo.Server(1234)
+except liblo.ServerError, err:
+    print str(err)
+    sys.exit()
+
+def foo_bar_callback(path, args):
+    i, f = args
+    print "received message '%s' with arguments '%d' and '%f'" % (path, i, f)
+
+def foo_baz_callback(path, args, types, src, data):
+    print "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.get_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)
+</pre>
+
+<h2>Example ServerThread, using the @make_method decorator</h2>
+
+<pre>
+#!/usr/bin/env python
+
+from liblo import *
+import sys
+
+class MyServer(ServerThread):
+    def __init__(self):
+        ServerThread.__init__(self, 1234)
+
+    @make_method('/foo', 'ifs')
+    def foo_callback(self, path, args):
+        i, f, s = args
+        print "received message '%s' with arguments: %d, %f, %s" % (path, i, f, s)
+
+    @make_method(None, None)
+    def fallback(self, path, args):
+        print "received unknown message '%s'" % path
+
+try:
+    server = MyServer()
+except ServerError, err:
+    print str(err)
+    sys.exit()
+
+server.start()
+raw_input("press enter to quit...\n")
+</pre>
+
+</body>
+
+</html>

scripts/dump_osc.1

+.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 <dominic.sacre@gmx.de>
+
+.SH SEE ALSO
+send_osc(1)

scripts/dump_osc.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007-2009  Dominic Sacré  <dominic.sacre@gmx.de>
+#
+# 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 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, 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

scripts/send_osc.1

+.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 <dominic.sacre@gmx.de>
+
+.SH SEE ALSO
+dump_osc(1)

scripts/send_osc.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007-2009  Dominic Sacré  <dominic.sacre@gmx.de>
+#
+# 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 liblo
+
+def send_osc_auto(port, path, *args):
+    m = liblo.Message(path)
+
+    for a in args:
+        try: v = int(a)
+        except ValueError:
+            try: v = float(a)
+            except ValueError:
+                v = a
+        m.add(v)
+
+    liblo.send(port, m)
+
+
+def send_osc_manual(port, path, types, *args):
+    if len(types) != len(args):
+        sys.exit("length of type string doesn't match number of arguments")
+
+    m = liblo.Message(path)
+    try:
+        for a, t in zip(args, types):
+            m.add((t, a))
+    except Exception, e:
+        sys.exit(str(e))
+
+    liblo.send(port, m)
+
+
+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(','):
+        send_osc_manual(sys.argv[1], sys.argv[2], sys.argv[3][1:], *sys.argv[4:])
+    else:
+        send_osc_auto(*sys.argv[1:])
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from distutils.core import setup, Extension
+from distutils.command.build_scripts import build_scripts
+from distutils import util, log
+import os, sys
+
+
+if '--with-pyrex' in sys.argv:
+    from Pyrex.Distutils import build_ext
+    sys.argv.remove('--with-pyrex')
+    compile_source = 'pyrex'
+elif '--with-cython' in sys.argv:
+    from Cython.Distutils import build_ext
+    sys.argv.remove('--with-cython')
+    compile_source = 'cython'
+else:
+    compile_source = ''
+
+
+class build_scripts_rename(build_scripts):
+    def copy_scripts(self):
+        build_scripts.copy_scripts(self)
+        # remove the .py extension from scripts
+        for s in self.scripts:
+            f = util.convert_path(s)
+            before = os.path.join(self.build_dir, os.path.basename(f))
+            after = os.path.splitext(before)[0]
+            log.info("renaming %s -> %s" % (before, after))
+            os.rename(before, after)
+
+
+cmdclass = {
+    'build_scripts': build_scripts_rename
+}
+
+ext_modules = [
+    Extension(
+        'liblo',
+        [compile_source and 'src/liblo.pyx' or 'src/liblo.c'],
+        extra_compile_args = [
+            '-fno-strict-aliasing',
+            '-Werror-implicit-function-declaration',
+        ],
+        libraries = ['lo']
+    )
+]
+
+if compile_source:
+    cmdclass['build_ext'] = build_ext
+
+
+setup (
+    name = 'pyliblo',
+    version = '0.8.1',
+    author = 'Dominic Sacre',
+    author_email = 'dominic.sacre@gmx.de',
+    url = 'http://das.nasophon.de/pyliblo/',
+    description = 'Python bindings for the liblo OSC library',
+    license = 'LGPL',
+    scripts = [
+        'scripts/send_osc.py',
+        'scripts/dump_osc.py',
+    ],
+    data_files = [
+        ('share/man/man1', [
+            'scripts/send_osc.1',
+            'scripts/dump_osc.1',
+        ]),
+    ],
+    cmdclass = cmdclass,
+    ext_modules = ext_modules
+)
+/* Generated by Pyrex 0.9.8.5 on Tue Sep 28 02:43:32 2010 */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "structmember.h"
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#if PY_VERSION_HEX < 0x02050000
+  typedef int Py_ssize_t;
+  #define PY_SSIZE_T_MAX INT_MAX
+  #define PY_SSIZE_T_MIN INT_MIN
+  #define PyInt_FromSsize_t(z) PyInt_FromLong(z)
+  #define PyInt_AsSsize_t(o)	PyInt_AsLong(o)
+#endif
+#if !defined(WIN32) && !defined(MS_WINDOWS)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+#endif
+#ifdef __cplusplus
+#define __PYX_EXTERN_C extern "C"
+#else
+#define __PYX_EXTERN_C extern
+#endif
+#include <math.h>
+#include "stdint.h"
+#include "stdlib.h"
+#include "math.h"
+#include "lo/lo.h"
+
+
+typedef struct {PyObject **p; int i; char *s; long n;} __Pyx_StringTabEntry; /*proto*/
+
+static PyObject *__pyx_m;
+static PyObject *__pyx_b;
+static int __pyx_lineno;
+static char *__pyx_filename;
+static char **__pyx_f;
+
+static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/
+
+static int __Pyx_GetStarArgs(PyObject **args, PyObject **kwds, char *kwd_list[],     Py_ssize_t nargs, PyObject **args2, PyObject **kwds2, char rqd_kwds[]); /*proto*/
+
+static PyObject *__Pyx_GetItemInt(PyObject *o, Py_ssize_t i); /*proto*/
+
+static void __Pyx_WriteUnraisable(char *name); /*proto*/
+
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
+
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+
+static PyObject *__Pyx_UnpackItem(PyObject *); /*proto*/
+static int __Pyx_EndUnpack(PyObject *); /*proto*/
+
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /*proto*/
+
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list); /*proto*/
+
+static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name, char *modname); /*proto*/
+
+static void __Pyx_AddTraceback(char *funcname); /*proto*/
+
+/* Declarations from liblo */
+
+
+/* Declarations from implementation of liblo */
+
+struct __pyx_obj_5liblo__ServerBase {
+  PyObject_HEAD
+  lo_server _serv;
+  PyObject *_keep_refs;
+};
+
+struct __pyx_obj_5liblo_Server {
+  struct __pyx_obj_5liblo__ServerBase __pyx_base;
+};
+
+struct __pyx_obj_5liblo_ServerThread {
+  struct __pyx_obj_5liblo__ServerBase __pyx_base;
+  lo_server_thread _thread;
+};
+
+struct __pyx_obj_5liblo_Address {
+  PyObject_HEAD
+  lo_address _addr;
+};
+
+struct __pyx_obj_5liblo__Blob {
+  PyObject_HEAD
+  lo_blob _blob;
+};
+
+struct __pyx_obj_5liblo_Message {
+  PyObject_HEAD
+  PyObject *_path;
+  lo_message _msg;
+  PyObject *_keep_refs;
+};
+
+struct __pyx_obj_5liblo_Bundle {
+  PyObject_HEAD
+  lo_bundle _bundle;
+  PyObject *_keep_refs;
+};
+
+
+
+
+
+
+
+
+static PyTypeObject *__pyx_ptype_5liblo__ServerBase = 0;
+static PyTypeObject *__pyx_ptype_5liblo_Address = 0;
+static PyTypeObject *__pyx_ptype_5liblo_Message = 0;
+static PyTypeObject *__pyx_ptype_5liblo_Bundle = 0;
+static PyTypeObject *__pyx_ptype_5liblo_Server = 0;
+static PyTypeObject *__pyx_ptype_5liblo_ServerThread = 0;
+static PyTypeObject *__pyx_ptype_5liblo__Blob = 0;
+static lo_timetag __pyx_f_5liblo__double_to_timetag(double); /*proto*/
+static double __pyx_f_5liblo__timetag_to_double(lo_timetag); /*proto*/
+static int __pyx_f_5liblo__callback(const char *,const char *,lo_arg **,int,lo_message,void *); /*proto*/
+static void __pyx_f_5liblo__err_handler(int,const char *,const char *); /*proto*/
+
+static char __pyx_k1[] = "im_func";
+static char __pyx_k2[] = "f";
+static char __pyx_k3[] = "_weakref";
+static char __pyx_k4[] = "ref";
+static char __pyx_k5[] = "im_self";
+static char __pyx_k6[] = "c";
+static char __pyx_k7[] = "__get__";
+static char __pyx_k8[] = "__class__";
+static char __pyx_k9[] = "_send";
+static char __pyx_k10[] = "num";
+static char __pyx_k11[] = "msg";
+static char __pyx_k12[] = "where";
+static char __pyx_k13[] = "server error %d";
+static char __pyx_k14[] = " in %s";
+static char __pyx_k15[] = ": %s";
+static char __pyx_k16[] = "func";
+static char __pyx_k17[] = "data";
+static char __pyx_k18[] = "chr";
+static char __pyx_k19[] = "i";
+static char __pyx_k20[] = "h";
+static char __pyx_k21[] = "d";
+static char __pyx_k22[] = "s";
+static char __pyx_k23[] = "S";
+static char __pyx_k24[] = "T";
+static char __pyx_k25[] = "F";
+static char __pyx_k26[] = "N";
+static char __pyx_k27[] = "I";
+static char __pyx_k28[] = "inf";
+static char __pyx_k29[] = "m";
+static char __pyx_k30[] = "t";
+static char __pyx_k31[] = "b";
+static char __pyx_k32[] = "append";
+static char __pyx_k33[] = "_weakref_method";
+static char __pyx_k34[] = "_inspect";
+static char __pyx_k35[] = "getargspec";
+static char __pyx_k36[] = "ismethod";
+static char __pyx_k37[] = "ServerError";
+static char __pyx_k38[] = "__exception";
+static char __pyx_k39[] = "make_method";
+static char __pyx_k40[] = "_counter";
+static char __pyx_k41[] = "spec";
+static char __pyx_k42[] = "_method_spec";
+static char __pyx_k43[] = "has_key";
+static char __pyx_k44[] = "reg_methods";
+static char __pyx_k45[] = "register_methods";
+static char __pyx_k46[] = "getmembers";
+static char __pyx_k47[] = "sort";
+static char __pyx_k48[] = "add_method";
+static char __pyx_k49[] = "path must be a string or None";
+static char __pyx_k50[] = "typespec must be a string or None";
+static char __pyx_k51[] = "_CallbackData";
+static char __pyx_k52[] = "__init__";
+static char __pyx_k53[] = "address error: %s";
+static char __pyx_k54[] = "AddressError";
+static char __pyx_k55[] = "invalid protocol";
+static char __pyx_k56[] = "isdigit";
+static char __pyx_k57[] = "invalid URL '%s'";
+static char __pyx_k58[] = "blob is empty";
+static char __pyx_k59[] = "ord";
+static char __pyx_k60[] = "add";
+static char __pyx_k61[] = "_add";
+static char __pyx_k62[] = "_add_auto";
+static char __pyx_k63[] = "unknown OSC data type '%s'";
+static char __pyx_k64[] = "unsupported message argument type";
+static char __pyx_k65[] = "invalid timetag";
+static char __pyx_k66[] = "0.8.1";
+static char __pyx_k67[] = "__version__";
+static char __pyx_k68[] = "inspect";
+static char __pyx_k69[] = "weakref";
+static char __pyx_k70[] = "__call__";
+static char __pyx_k71[] = "UDP";
+static char __pyx_k72[] = "TCP";
+static char __pyx_k73[] = "UNIX";
+static char __pyx_k74[] = "__str__";
+
+static PyObject *__pyx_n_AddressError;
+static PyObject *__pyx_n_F;
+static PyObject *__pyx_n_I;
+static PyObject *__pyx_n_N;
+static PyObject *__pyx_n_S;
+static PyObject *__pyx_n_ServerError;
+static PyObject *__pyx_n_T;
+static PyObject *__pyx_n_TCP;
+static PyObject *__pyx_n_UDP;
+static PyObject *__pyx_n_UNIX;
+static PyObject *__pyx_n__CallbackData;
+static PyObject *__pyx_n___call__;
+static PyObject *__pyx_n___class__;
+static PyObject *__pyx_n___exception;
+static PyObject *__pyx_n___get__;
+static PyObject *__pyx_n___init__;
+static PyObject *__pyx_n___str__;
+static PyObject *__pyx_n___version__;
+static PyObject *__pyx_n__add;
+static PyObject *__pyx_n__add_auto;
+static PyObject *__pyx_n__counter;
+static PyObject *__pyx_n__inspect;
+static PyObject *__pyx_n__method_spec;
+static PyObject *__pyx_n__send;
+static PyObject *__pyx_n__weakref;
+static PyObject *__pyx_n__weakref_method;
+static PyObject *__pyx_n_add;
+static PyObject *__pyx_n_add_method;
+static PyObject *__pyx_n_append;
+static PyObject *__pyx_n_b;
+static PyObject *__pyx_n_c;
+static PyObject *__pyx_n_chr;
+static PyObject *__pyx_n_d;
+static PyObject *__pyx_n_data;
+static PyObject *__pyx_n_f;
+static PyObject *__pyx_n_func;
+static PyObject *__pyx_n_getargspec;
+static PyObject *__pyx_n_getmembers;
+static PyObject *__pyx_n_h;
+static PyObject *__pyx_n_has_key;
+static PyObject *__pyx_n_i;
+static PyObject *__pyx_n_im_func;
+static PyObject *__pyx_n_im_self;
+static PyObject *__pyx_n_inf;
+static PyObject *__pyx_n_inspect;
+static PyObject *__pyx_n_isdigit;
+static PyObject *__pyx_n_ismethod;
+static PyObject *__pyx_n_m;
+static PyObject *__pyx_n_make_method;
+static PyObject *__pyx_n_msg;
+static PyObject *__pyx_n_num;
+static PyObject *__pyx_n_ord;
+static PyObject *__pyx_n_ref;
+static PyObject *__pyx_n_reg_methods;
+static PyObject *__pyx_n_register_methods;
+static PyObject *__pyx_n_s;
+static PyObject *__pyx_n_sort;
+static PyObject *__pyx_n_spec;
+static PyObject *__pyx_n_t;
+static PyObject *__pyx_n_weakref;
+static PyObject *__pyx_n_where;
+
+static PyObject *__pyx_k13p;
+static PyObject *__pyx_k14p;
+static PyObject *__pyx_k15p;
+static PyObject *__pyx_k49p;
+static PyObject *__pyx_k50p;
+static PyObject *__pyx_k53p;
+static PyObject *__pyx_k55p;
+static PyObject *__pyx_k57p;
+static PyObject *__pyx_k58p;
+static PyObject *__pyx_k63p;
+static PyObject *__pyx_k64p;
+static PyObject *__pyx_k65p;
+static PyObject *__pyx_k66p;
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_n_AddressError, 1, __pyx_k54, sizeof(__pyx_k54)},
+  {&__pyx_n_F, 1, __pyx_k25, sizeof(__pyx_k25)},
+  {&__pyx_n_I, 1, __pyx_k27, sizeof(__pyx_k27)},
+  {&__pyx_n_N, 1, __pyx_k26, sizeof(__pyx_k26)},
+  {&__pyx_n_S, 1, __pyx_k23, sizeof(__pyx_k23)},
+  {&__pyx_n_ServerError, 1, __pyx_k37, sizeof(__pyx_k37)},
+  {&__pyx_n_T, 1, __pyx_k24, sizeof(__pyx_k24)},
+  {&__pyx_n_TCP, 1, __pyx_k72, sizeof(__pyx_k72)},
+  {&__pyx_n_UDP, 1, __pyx_k71, sizeof(__pyx_k71)},
+  {&__pyx_n_UNIX, 1, __pyx_k73, sizeof(__pyx_k73)},
+  {&__pyx_n__CallbackData, 1, __pyx_k51, sizeof(__pyx_k51)},
+  {&__pyx_n___call__, 1, __pyx_k70, sizeof(__pyx_k70)},
+  {&__pyx_n___class__, 1, __pyx_k8, sizeof(__pyx_k8)},
+  {&__pyx_n___exception, 1, __pyx_k38, sizeof(__pyx_k38)},
+  {&__pyx_n___get__, 1, __pyx_k7, sizeof(__pyx_k7)},
+  {&__pyx_n___init__, 1, __pyx_k52, sizeof(__pyx_k52)},
+  {&__pyx_n___str__, 1, __pyx_k74, sizeof(__pyx_k74)},
+  {&__pyx_n___version__, 1, __pyx_k67, sizeof(__pyx_k67)},
+  {&__pyx_n__add, 1, __pyx_k61, sizeof(__pyx_k61)},
+  {&__pyx_n__add_auto, 1, __pyx_k62, sizeof(__pyx_k62)},
+  {&__pyx_n__counter, 1, __pyx_k40, sizeof(__pyx_k40)},
+  {&__pyx_n__inspect, 1, __pyx_k34, sizeof(__pyx_k34)},
+  {&__pyx_n__method_spec, 1, __pyx_k42, sizeof(__pyx_k42)},
+  {&__pyx_n__send, 1, __pyx_k9, sizeof(__pyx_k9)},
+  {&__pyx_n__weakref, 1, __pyx_k3, sizeof(__pyx_k3)},
+  {&__pyx_n__weakref_method, 1, __pyx_k33, sizeof(__pyx_k33)},
+  {&__pyx_n_add, 1, __pyx_k60, sizeof(__pyx_k60)},
+  {&__pyx_n_add_method, 1, __pyx_k48, sizeof(__pyx_k48)},
+  {&__pyx_n_append, 1, __pyx_k32, sizeof(__pyx_k32)},
+  {&__pyx_n_b, 1, __pyx_k31, sizeof(__pyx_k31)},
+  {&__pyx_n_c, 1, __pyx_k6, sizeof(__pyx_k6)},
+  {&__pyx_n_chr, 1, __pyx_k18, sizeof(__pyx_k18)},
+  {&__pyx_n_d, 1, __pyx_k21, sizeof(__pyx_k21)},
+  {&__pyx_n_data, 1, __pyx_k17, sizeof(__pyx_k17)},
+  {&__pyx_n_f, 1, __pyx_k2, sizeof(__pyx_k2)},
+  {&__pyx_n_func, 1, __pyx_k16, sizeof(__pyx_k16)},
+  {&__pyx_n_getargspec, 1, __pyx_k35, sizeof(__pyx_k35)},
+  {&__pyx_n_getmembers, 1, __pyx_k46, sizeof(__pyx_k46)},
+  {&__pyx_n_h, 1, __pyx_k20, sizeof(__pyx_k20)},
+  {&__pyx_n_has_key, 1, __pyx_k43, sizeof(__pyx_k43)},
+  {&__pyx_n_i, 1, __pyx_k19, sizeof(__pyx_k19)},
+  {&__pyx_n_im_func, 1, __pyx_k1, sizeof(__pyx_k1)},
+  {&__pyx_n_im_self, 1, __pyx_k5, sizeof(__pyx_k5)},
+  {&__pyx_n_inf, 1, __pyx_k28, sizeof(__pyx_k28)},
+  {&__pyx_n_inspect, 1, __pyx_k68, sizeof(__pyx_k68)},
+  {&__pyx_n_isdigit, 1, __pyx_k56, sizeof(__pyx_k56)},
+  {&__pyx_n_ismethod, 1, __pyx_k36, sizeof(__pyx_k36)},
+  {&__pyx_n_m, 1, __pyx_k29, sizeof(__pyx_k29)},
+  {&__pyx_n_make_method, 1, __pyx_k39, sizeof(__pyx_k39)},
+  {&__pyx_n_msg, 1, __pyx_k11, sizeof(__pyx_k11)},
+  {&__pyx_n_num, 1, __pyx_k10, sizeof(__pyx_k10)},
+  {&__pyx_n_ord, 1, __pyx_k59, sizeof(__pyx_k59)},
+  {&__pyx_n_ref, 1, __pyx_k4, sizeof(__pyx_k4)},
+  {&__pyx_n_reg_methods, 1, __pyx_k44, sizeof(__pyx_k44)},
+  {&__pyx_n_register_methods, 1, __pyx_k45, sizeof(__pyx_k45)},
+  {&__pyx_n_s, 1, __pyx_k22, sizeof(__pyx_k22)},
+  {&__pyx_n_sort, 1, __pyx_k47, sizeof(__pyx_k47)},
+  {&__pyx_n_spec, 1, __pyx_k41, sizeof(__pyx_k41)},
+  {&__pyx_n_t, 1, __pyx_k30, sizeof(__pyx_k30)},
+  {&__pyx_n_weakref, 1, __pyx_k69, sizeof(__pyx_k69)},
+  {&__pyx_n_where, 1, __pyx_k12, sizeof(__pyx_k12)},
+  {&__pyx_k13p, 0, __pyx_k13, sizeof(__pyx_k13)},
+  {&__pyx_k14p, 0, __pyx_k14, sizeof(__pyx_k14)},
+  {&__pyx_k15p, 0, __pyx_k15, sizeof(__pyx_k15)},
+  {&__pyx_k49p, 0, __pyx_k49, sizeof(__pyx_k49)},
+  {&__pyx_k50p, 0, __pyx_k50, sizeof(__pyx_k50)},
+  {&__pyx_k53p, 0, __pyx_k53, sizeof(__pyx_k53)},
+  {&__pyx_k55p, 0, __pyx_k55, sizeof(__pyx_k55)},
+  {&__pyx_k57p, 0, __pyx_k57, sizeof(__pyx_k57)},
+  {&__pyx_k58p, 0, __pyx_k58, sizeof(__pyx_k58)},
+  {&__pyx_k63p, 0, __pyx_k63, sizeof(__pyx_k63)},
+  {&__pyx_k64p, 0, __pyx_k64, sizeof(__pyx_k64)},
+  {&__pyx_k65p, 0, __pyx_k65, sizeof(__pyx_k65)},
+  {&__pyx_k66p, 0, __pyx_k66, sizeof(__pyx_k66)},
+  {0, 0, 0, 0}
+};
+
+static PyObject *__pyx_d1;
+static PyObject *__pyx_d2;
+static PyObject *__pyx_d3;
+static PyObject *__pyx_d4;
+static PyObject *__pyx_d5;
+static PyObject *__pyx_d6;
+static PyObject *__pyx_d7;
+static PyObject *__pyx_d8;
+static PyObject *__pyx_d9;
+static PyObject *__pyx_d10;
+
+
+/* Implementation of liblo */
+
+static PyObject *__pyx_f_5liblo_15_weakref_method___init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_5liblo_15_weakref_method___init__ = {"__init__", (PyCFunction)__pyx_f_5liblo_15_weakref_method___init__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_f_5liblo_15_weakref_method___init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_f = 0;
+  PyObject *__pyx_r;
+  PyObject *__pyx_1 = 0;
+  PyObject *__pyx_2 = 0;
+  PyObject *__pyx_3 = 0;
+  static char *__pyx_argnames[] = {"self","f",0};
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "OO", __pyx_argnames, &__pyx_v_self, &__pyx_v_f)) return 0;
+  Py_INCREF(__pyx_v_self);
+  Py_INCREF(__pyx_v_f);
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":138 */
+  __pyx_1 = PyObject_GetAttr(__pyx_v_f, __pyx_n_im_func); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; goto __pyx_L1;}
+  if (PyObject_SetAttr(__pyx_v_self, __pyx_n_f, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":139 */
+  __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__weakref); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; goto __pyx_L1;}
+  __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_ref); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_1 = PyObject_GetAttr(__pyx_v_f, __pyx_n_im_self); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; goto __pyx_L1;}
+  __pyx_3 = PyTuple_New(1); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_3, 0, __pyx_1);
+  __pyx_1 = 0;
+  __pyx_1 = PyObject_CallObject(__pyx_2, __pyx_3); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  if (PyObject_SetAttr(__pyx_v_self, __pyx_n_c, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  Py_XDECREF(__pyx_1);
+  Py_XDECREF(__pyx_2);
+  Py_XDECREF(__pyx_3);
+  __Pyx_AddTraceback("liblo._weakref_method.__init__");
+  __pyx_r = 0;
+  __pyx_L0:;
+  Py_DECREF(__pyx_v_self);
+  Py_DECREF(__pyx_v_f);
+  return __pyx_r;
+}
+
+static PyObject *__pyx_f_5liblo_15_weakref_method___call__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_5liblo_15_weakref_method___call__ = {"__call__", (PyCFunction)__pyx_f_5liblo_15_weakref_method___call__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_f_5liblo_15_weakref_method___call__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_r;
+  PyObject *__pyx_1 = 0;
+  PyObject *__pyx_2 = 0;
+  PyObject *__pyx_3 = 0;
+  PyObject *__pyx_4 = 0;
+  static char *__pyx_argnames[] = {"self",0};
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_self)) return 0;
+  Py_INCREF(__pyx_v_self);
+  __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_f); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n___get__); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_c); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  __pyx_3 = PyObject_CallObject(__pyx_1, 0); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_c); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  __pyx_4 = PyObject_CallObject(__pyx_1, 0); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_1 = PyObject_GetAttr(__pyx_4, __pyx_n___class__); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  Py_DECREF(__pyx_4); __pyx_4 = 0;
+  __pyx_4 = PyTuple_New(2); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  PyTuple_SET_ITEM(__pyx_4, 0, __pyx_3);
+  PyTuple_SET_ITEM(__pyx_4, 1, __pyx_1);
+  __pyx_3 = 0;
+  __pyx_1 = 0;
+  __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_4); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  Py_DECREF(__pyx_4); __pyx_4 = 0;
+  __pyx_r = __pyx_3;
+  __pyx_3 = 0;
+  goto __pyx_L0;
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  Py_XDECREF(__pyx_1);
+  Py_XDECREF(__pyx_2);
+  Py_XDECREF(__pyx_3);
+  Py_XDECREF(__pyx_4);
+  __Pyx_AddTraceback("liblo._weakref_method.__call__");
+  __pyx_r = 0;
+  __pyx_L0:;
+  Py_DECREF(__pyx_v_self);
+  return __pyx_r;
+}
+
+static lo_timetag __pyx_f_5liblo__double_to_timetag(double __pyx_v_f) {
+  lo_timetag __pyx_v_tt;
+  double __pyx_v_intr;
+  double __pyx_v_frac;
+  lo_timetag __pyx_r;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":162 */
+  __pyx_v_frac = modf(__pyx_v_f,(&__pyx_v_intr));
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":163 */
+  __pyx_v_tt.sec = ((uint32_t)__pyx_v_intr);
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":164 */
+  __pyx_v_tt.frac = ((uint32_t)(__pyx_v_frac * 4294967296.0));
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":165 */
+  __pyx_r = __pyx_v_tt;
+  goto __pyx_L0;
+
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+static double __pyx_f_5liblo__timetag_to_double(lo_timetag __pyx_v_tt) {
+  double __pyx_r;
+  __pyx_r = (((double)__pyx_v_tt.sec) + (((double)__pyx_v_tt.frac) / 4294967296.0));
+  goto __pyx_L0;
+
+  __pyx_r = 0;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+static PyObject *__pyx_f_5liblo_time(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_f_5liblo_time(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  lo_timetag __pyx_v_tt;
+  PyObject *__pyx_r;
+  PyObject *__pyx_1 = 0;
+  static char *__pyx_argnames[] = {0};
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "", __pyx_argnames)) return 0;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":172 */
+  lo_timetag_now((&__pyx_v_tt));
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":173 */
+  __pyx_1 = PyFloat_FromDouble(__pyx_f_5liblo__timetag_to_double(__pyx_v_tt)); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 173; goto __pyx_L1;}
+  __pyx_r = __pyx_1;
+  __pyx_1 = 0;
+  goto __pyx_L0;
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  Py_XDECREF(__pyx_1);
+  __Pyx_AddTraceback("liblo.time");
+  __pyx_r = 0;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+static PyObject *__pyx_f_5liblo__send(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_f_5liblo__send(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_target = 0;
+  PyObject *__pyx_v_src = 0;
+  PyObject *__pyx_v_msg = 0;
+  lo_server __pyx_v_serv;
+  PyObject *__pyx_v_addr;
+  PyObject *__pyx_v_m;
+  PyObject *__pyx_r;
+  int __pyx_1;
+  PyObject *__pyx_2 = 0;
+  PyObject *__pyx_3 = 0;
+  int __pyx_4;
+  char *__pyx_5;
+  static char *__pyx_argnames[] = {"target","src",0};
+  if (__Pyx_GetStarArgs(&__pyx_args, &__pyx_kwds, __pyx_argnames, 2, &__pyx_v_msg, 0, 0) < 0) return 0;
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "OO", __pyx_argnames, &__pyx_v_target, &__pyx_v_src)) {
+    Py_XDECREF(__pyx_args);
+    Py_XDECREF(__pyx_kwds);
+    Py_XDECREF(__pyx_v_msg);
+    return 0;
+  }
+  Py_INCREF(__pyx_v_target);
+  Py_INCREF(__pyx_v_src);
+  __pyx_v_addr = Py_None; Py_INCREF(Py_None);
+  __pyx_v_m = Py_None; Py_INCREF(Py_None);
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":183 */
+  __pyx_1 = PyObject_IsInstance(__pyx_v_target,((PyObject *)__pyx_ptype_5liblo_Address)); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 183; goto __pyx_L1;}
+  if (__pyx_1) {
+    Py_INCREF(__pyx_v_target);
+    Py_DECREF(__pyx_v_addr);
+    __pyx_v_addr = __pyx_v_target;
+    goto __pyx_L2;
+  }
+  __pyx_1 = PyObject_IsInstance(__pyx_v_target,((PyObject *)(&PyTuple_Type))); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 185; goto __pyx_L1;}
+  if (__pyx_1) {
+    __pyx_2 = PySequence_Tuple(__pyx_v_target); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 187; goto __pyx_L1;}
+    __pyx_3 = PyObject_CallObject(((PyObject *)__pyx_ptype_5liblo_Address), __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 187; goto __pyx_L1;}
+    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    Py_DECREF(__pyx_v_addr);
+    __pyx_v_addr = __pyx_3;
+    __pyx_3 = 0;
+    goto __pyx_L2;
+  }
+  /*else*/ {
+    __pyx_2 = PyTuple_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 189; goto __pyx_L1;}
+    Py_INCREF(__pyx_v_target);
+    PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_target);
+    __pyx_3 = PyObject_CallObject(((PyObject *)__pyx_ptype_5liblo_Address), __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 189; goto __pyx_L1;}
+    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    Py_DECREF(__pyx_v_addr);
+    __pyx_v_addr = __pyx_3;
+    __pyx_3 = 0;
+  }
+  __pyx_L2:;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":191 */
+  __pyx_2 = __Pyx_GetItemInt(__pyx_v_msg, 0); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 191; goto __pyx_L1;}
+  __pyx_3 = PyTuple_New(2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 191; goto __pyx_L1;}
+  Py_INCREF(((PyObject *)__pyx_ptype_5liblo_Message));
+  PyTuple_SET_ITEM(__pyx_3, 0, ((PyObject *)__pyx_ptype_5liblo_Message));
+  Py_INCREF(((PyObject *)__pyx_ptype_5liblo_Bundle));
+  PyTuple_SET_ITEM(__pyx_3, 1, ((PyObject *)__pyx_ptype_5liblo_Bundle));
+  __pyx_1 = PyObject_IsInstance(__pyx_2,__pyx_3); if (__pyx_1 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 191; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  __pyx_4 = (!__pyx_1);
+  if (__pyx_4) {
+    __pyx_2 = PySequence_Tuple(__pyx_v_msg); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 193; goto __pyx_L1;}
+    __pyx_3 = PyObject_CallObject(((PyObject *)__pyx_ptype_5liblo_Message), __pyx_2); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 193; goto __pyx_L1;}
+    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    __pyx_2 = PyList_New(1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 193; goto __pyx_L1;}
+    PyList_SET_ITEM(__pyx_2, 0, __pyx_3);
+    __pyx_3 = 0;
+    Py_DECREF(__pyx_v_msg);
+    __pyx_v_msg = __pyx_2;
+    __pyx_2 = 0;
+    goto __pyx_L3;
+  }
+  __pyx_L3:;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":195 */
+  __pyx_1 = PyObject_IsTrue(__pyx_v_src); if (__pyx_1 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 195; goto __pyx_L1;}
+  if (__pyx_1) {
+    __pyx_v_serv = ((struct __pyx_obj_5liblo__ServerBase *)__pyx_v_src)->_serv;
+    goto __pyx_L4;
+  }
+  /*else*/ {
+    __pyx_v_serv = NULL;
+  }
+  __pyx_L4:;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":200 */
+  __pyx_3 = PyObject_GetIter(__pyx_v_msg); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; goto __pyx_L1;}
+  for (;;) {
+    __pyx_2 = PyIter_Next(__pyx_3);
+    if (!__pyx_2) {
+      if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; goto __pyx_L1;}
+      break;
+    }
+    Py_DECREF(__pyx_v_m);
+    __pyx_v_m = __pyx_2;
+    __pyx_2 = 0;
+    __pyx_4 = PyObject_IsInstance(__pyx_v_m,((PyObject *)__pyx_ptype_5liblo_Message)); if (__pyx_4 == -1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 201; goto __pyx_L1;}
+    if (__pyx_4) {
+      __pyx_5 = PyString_AsString(((struct __pyx_obj_5liblo_Message *)__pyx_v_m)->_path); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 202; goto __pyx_L1;}
+      lo_send_message_from(((struct __pyx_obj_5liblo_Address *)__pyx_v_addr)->_addr,__pyx_v_serv,__pyx_5,((struct __pyx_obj_5liblo_Message *)__pyx_v_m)->_msg);
+      goto __pyx_L7;
+    }
+    /*else*/ {
+      lo_send_bundle_from(((struct __pyx_obj_5liblo_Address *)__pyx_v_addr)->_addr,__pyx_v_serv,((struct __pyx_obj_5liblo_Bundle *)__pyx_v_m)->_bundle);
+    }
+    __pyx_L7:;
+  }
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  Py_XDECREF(__pyx_2);
+  Py_XDECREF(__pyx_3);
+  __Pyx_AddTraceback("liblo._send");
+  __pyx_r = 0;
+  __pyx_L0:;
+  Py_XDECREF(__pyx_v_msg);
+  Py_DECREF(__pyx_v_addr);
+  Py_DECREF(__pyx_v_m);
+  Py_DECREF(__pyx_v_target);
+  Py_DECREF(__pyx_v_src);
+  Py_XDECREF(__pyx_args);
+  Py_XDECREF(__pyx_kwds);
+  return __pyx_r;
+}
+
+static PyObject *__pyx_f_5liblo_send(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_f_5liblo_send(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_target = 0;
+  PyObject *__pyx_v_msg = 0;
+  PyObject *__pyx_r;
+  PyObject *__pyx_1 = 0;
+  PyObject *__pyx_2 = 0;
+  PyObject *__pyx_3 = 0;
+  PyObject *__pyx_4 = 0;
+  static char *__pyx_argnames[] = {"target",0};
+  if (__Pyx_GetStarArgs(&__pyx_args, &__pyx_kwds, __pyx_argnames, 1, &__pyx_v_msg, 0, 0) < 0) return 0;
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_target)) {
+    Py_XDECREF(__pyx_args);
+    Py_XDECREF(__pyx_kwds);
+    Py_XDECREF(__pyx_v_msg);
+    return 0;
+  }
+  Py_INCREF(__pyx_v_target);
+  __pyx_1 = __Pyx_GetName(__pyx_m, __pyx_n__send); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; goto __pyx_L1;}
+  __pyx_2 = PyTuple_New(2); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; goto __pyx_L1;}
+  Py_INCREF(__pyx_v_target);
+  PyTuple_SET_ITEM(__pyx_2, 0, __pyx_v_target);
+  Py_INCREF(Py_None);
+  PyTuple_SET_ITEM(__pyx_2, 1, Py_None);
+  __pyx_3 = PySequence_Tuple(__pyx_v_msg); if (!__pyx_3) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; goto __pyx_L1;}
+  __pyx_4 = PyNumber_Add(__pyx_2, __pyx_3); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  Py_DECREF(__pyx_3); __pyx_3 = 0;
+  __pyx_2 = PyObject_CallObject(__pyx_1, __pyx_4); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  Py_DECREF(__pyx_4); __pyx_4 = 0;
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  Py_XDECREF(__pyx_1);
+  Py_XDECREF(__pyx_2);
+  Py_XDECREF(__pyx_3);
+  Py_XDECREF(__pyx_4);
+  __Pyx_AddTraceback("liblo.send");
+  __pyx_r = 0;
+  __pyx_L0:;
+  Py_XDECREF(__pyx_v_msg);
+  Py_DECREF(__pyx_v_target);
+  Py_XDECREF(__pyx_args);
+  Py_XDECREF(__pyx_kwds);
+  return __pyx_r;
+}
+
+static PyObject *__pyx_f_5liblo_11ServerError___init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_5liblo_11ServerError___init__ = {"__init__", (PyCFunction)__pyx_f_5liblo_11ServerError___init__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_f_5liblo_11ServerError___init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_num = 0;
+  PyObject *__pyx_v_msg = 0;
+  PyObject *__pyx_v_where = 0;
+  PyObject *__pyx_r;
+  static char *__pyx_argnames[] = {"self","num","msg","where",0};
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "OOOO", __pyx_argnames, &__pyx_v_self, &__pyx_v_num, &__pyx_v_msg, &__pyx_v_where)) return 0;
+  Py_INCREF(__pyx_v_self);
+  Py_INCREF(__pyx_v_num);
+  Py_INCREF(__pyx_v_msg);
+  Py_INCREF(__pyx_v_where);
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":217 */
+  if (PyObject_SetAttr(__pyx_v_self, __pyx_n_num, __pyx_v_num) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; goto __pyx_L1;}
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":218 */
+  if (PyObject_SetAttr(__pyx_v_self, __pyx_n_msg, __pyx_v_msg) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; goto __pyx_L1;}
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":219 */
+  if (PyObject_SetAttr(__pyx_v_self, __pyx_n_where, __pyx_v_where) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; goto __pyx_L1;}
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  __Pyx_AddTraceback("liblo.ServerError.__init__");
+  __pyx_r = 0;
+  __pyx_L0:;
+  Py_DECREF(__pyx_v_self);
+  Py_DECREF(__pyx_v_num);
+  Py_DECREF(__pyx_v_msg);
+  Py_DECREF(__pyx_v_where);
+  return __pyx_r;
+}
+
+static PyObject *__pyx_f_5liblo_11ServerError___str__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_5liblo_11ServerError___str__ = {"__str__", (PyCFunction)__pyx_f_5liblo_11ServerError___str__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_f_5liblo_11ServerError___str__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_s;
+  PyObject *__pyx_r;
+  PyObject *__pyx_1 = 0;
+  PyObject *__pyx_2 = 0;
+  int __pyx_3;
+  static char *__pyx_argnames[] = {"self",0};
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_self)) return 0;
+  Py_INCREF(__pyx_v_self);
+  __pyx_v_s = Py_None; Py_INCREF(Py_None);
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":221 */
+  __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_num); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 221; goto __pyx_L1;}
+  __pyx_2 = PyNumber_Remainder(__pyx_k13p, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 221; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  Py_DECREF(__pyx_v_s);
+  __pyx_v_s = __pyx_2;
+  __pyx_2 = 0;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":222 */
+  __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_where); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; goto __pyx_L1;}
+  __pyx_3 = PyObject_IsTrue(__pyx_1); if (__pyx_3 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  if (__pyx_3) {
+    __pyx_2 = PyObject_GetAttr(__pyx_v_self, __pyx_n_where); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; goto __pyx_L1;}
+    __pyx_1 = PyNumber_Remainder(__pyx_k14p, __pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; goto __pyx_L1;}
+    Py_DECREF(__pyx_2); __pyx_2 = 0;
+    __pyx_2 = PyNumber_InPlaceAdd(__pyx_v_s, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; goto __pyx_L1;}
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
+    Py_DECREF(__pyx_v_s);
+    __pyx_v_s = __pyx_2;
+    goto __pyx_L2;
+  }
+  __pyx_L2:;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":223 */
+  __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_msg); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; goto __pyx_L1;}
+  __pyx_2 = PyNumber_Remainder(__pyx_k15p, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; goto __pyx_L1;}
+  Py_DECREF(__pyx_1); __pyx_1 = 0;
+  __pyx_1 = PyNumber_InPlaceAdd(__pyx_v_s, __pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; goto __pyx_L1;}
+  Py_DECREF(__pyx_2); __pyx_2 = 0;
+  Py_DECREF(__pyx_v_s);
+  __pyx_v_s = __pyx_1;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":224 */
+  Py_INCREF(__pyx_v_s);
+  __pyx_r = __pyx_v_s;
+  goto __pyx_L0;
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  Py_XDECREF(__pyx_1);
+  Py_XDECREF(__pyx_2);
+  __Pyx_AddTraceback("liblo.ServerError.__str__");
+  __pyx_r = 0;
+  __pyx_L0:;
+  Py_DECREF(__pyx_v_s);
+  Py_DECREF(__pyx_v_self);
+  return __pyx_r;
+}
+
+static PyObject *__pyx_f_5liblo_13_CallbackData___init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_5liblo_13_CallbackData___init__ = {"__init__", (PyCFunction)__pyx_f_5liblo_13_CallbackData___init__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_f_5liblo_13_CallbackData___init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_func = 0;
+  PyObject *__pyx_v_data = 0;
+  PyObject *__pyx_r;
+  static char *__pyx_argnames[] = {"self","func","data",0};
+  if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "OOO", __pyx_argnames, &__pyx_v_self, &__pyx_v_func, &__pyx_v_data)) return 0;
+  Py_INCREF(__pyx_v_self);
+  Py_INCREF(__pyx_v_func);
+  Py_INCREF(__pyx_v_data);
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":229 */
+  if (PyObject_SetAttr(__pyx_v_self, __pyx_n_func, __pyx_v_func) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; goto __pyx_L1;}
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":230 */
+  if (PyObject_SetAttr(__pyx_v_self, __pyx_n_data, __pyx_v_data) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; goto __pyx_L1;}
+
+  __pyx_r = Py_None; Py_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1:;
+  __Pyx_AddTraceback("liblo._CallbackData.__init__");
+  __pyx_r = 0;
+  __pyx_L0:;
+  Py_DECREF(__pyx_v_self);
+  Py_DECREF(__pyx_v_func);
+  Py_DECREF(__pyx_v_data);
+  return __pyx_r;
+}
+
+static int __pyx_f_5liblo__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) {
+  unsigned char *__pyx_v_ptr;
+  uint32_t __pyx_v_size;
+  uint32_t __pyx_v_j;
+  char *__pyx_v_url;
+  PyObject *__pyx_v_args;
+  PyObject *__pyx_v_i;
+  PyObject *__pyx_v_t;
+  PyObject *__pyx_v_v;
+  PyObject *__pyx_v_src;
+  PyObject *__pyx_v_cb;
+  PyObject *__pyx_v_func;
+  PyObject *__pyx_v_func_args;
+  PyObject *__pyx_v_n;
+  PyObject *__pyx_v_r;
+  int __pyx_r;
+  PyObject *__pyx_1 = 0;
+  long __pyx_2;
+  Py_ssize_t __pyx_3;
+  PyObject *__pyx_4 = 0;
+  PyObject *__pyx_5 = 0;
+  int __pyx_6;
+  PyObject *__pyx_7 = 0;
+  PyObject *__pyx_8 = 0;
+  PyGILState_STATE _save = PyGILState_Ensure();
+  __pyx_v_args = Py_None; Py_INCREF(Py_None);
+  __pyx_v_i = Py_None; Py_INCREF(Py_None);
+  __pyx_v_t = Py_None; Py_INCREF(Py_None);
+  __pyx_v_v = Py_None; Py_INCREF(Py_None);
+  __pyx_v_src = Py_None; Py_INCREF(Py_None);
+  __pyx_v_cb = Py_None; Py_INCREF(Py_None);
+  __pyx_v_func = Py_None; Py_INCREF(Py_None);
+  __pyx_v_func_args = Py_None; Py_INCREF(Py_None);
+  __pyx_v_n = Py_None; Py_INCREF(Py_None);
+  __pyx_v_r = Py_None; Py_INCREF(Py_None);
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":237 */
+  __pyx_1 = PyList_New(0); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; goto __pyx_L1;}
+  Py_DECREF(__pyx_v_args);
+  __pyx_v_args = __pyx_1;
+  __pyx_1 = 0;
+
+  /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":239 */
+  for (__pyx_2 = 0; __pyx_2 < __pyx_v_argc; ++__pyx_2) {
+    __pyx_1 = PyInt_FromLong(__pyx_2); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 239; goto __pyx_L1;}
+    Py_DECREF(__pyx_v_i);
+    __pyx_v_i = __pyx_1;
+    __pyx_1 = 0;
+
+    /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":240 */
+    __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_chr); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; goto __pyx_L1;}
+    __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; goto __pyx_L1;}
+    __pyx_4 = PyInt_FromLong((__pyx_v_types[__pyx_3])); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; goto __pyx_L1;}
+    __pyx_5 = PyTuple_New(1); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; goto __pyx_L1;}
+    PyTuple_SET_ITEM(__pyx_5, 0, __pyx_4);
+    __pyx_4 = 0;
+    __pyx_4 = PyObject_CallObject(__pyx_1, __pyx_5); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; goto __pyx_L1;}
+    Py_DECREF(__pyx_1); __pyx_1 = 0;
+    Py_DECREF(__pyx_5); __pyx_5 = 0;
+    Py_DECREF(__pyx_v_t);
+    __pyx_v_t = __pyx_4;
+    __pyx_4 = 0;
+
+    /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":241 */
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_i, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 241; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 241; goto __pyx_L1;}
+      __pyx_1 = PyInt_FromLong((__pyx_v_argv[__pyx_3])->i); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 241; goto __pyx_L1;}
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_1;
+      __pyx_1 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_h, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; goto __pyx_L1;}
+      __pyx_5 = PyLong_FromLongLong((__pyx_v_argv[__pyx_3])->h); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; goto __pyx_L1;}
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_5;
+      __pyx_5 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_f, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 243; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 243; goto __pyx_L1;}
+      __pyx_4 = PyFloat_FromDouble((__pyx_v_argv[__pyx_3])->f); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 243; goto __pyx_L1;}
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_4;
+      __pyx_4 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_d, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 244; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 244; goto __pyx_L1;}
+      __pyx_1 = PyFloat_FromDouble((__pyx_v_argv[__pyx_3])->d); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 244; goto __pyx_L1;}
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_1;
+      __pyx_1 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_c, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_5 = __Pyx_GetName(__pyx_b, __pyx_n_chr); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; goto __pyx_L1;}
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; goto __pyx_L1;}
+      __pyx_4 = PyInt_FromLong((__pyx_v_argv[__pyx_3])->c); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; goto __pyx_L1;}
+      __pyx_1 = PyTuple_New(1); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; goto __pyx_L1;}
+      PyTuple_SET_ITEM(__pyx_1, 0, __pyx_4);
+      __pyx_4 = 0;
+      __pyx_4 = PyObject_CallObject(__pyx_5, __pyx_1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; goto __pyx_L1;}
+      Py_DECREF(__pyx_5); __pyx_5 = 0;
+      Py_DECREF(__pyx_1); __pyx_1 = 0;
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_4;
+      __pyx_4 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_s, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; goto __pyx_L1;}
+      __pyx_5 = PyString_FromString((&(__pyx_v_argv[__pyx_3])->s)); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; goto __pyx_L1;}
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_5;
+      __pyx_5 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_S, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; goto __pyx_L1;}
+      __pyx_1 = PyString_FromString((&(__pyx_v_argv[__pyx_3])->s)); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; goto __pyx_L1;}
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_1;
+      __pyx_1 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_T, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      Py_INCREF(Py_True);
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = Py_True;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_F, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 249; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      Py_INCREF(Py_False);
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = Py_False;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_N, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 250; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      Py_INCREF(Py_None);
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = Py_None;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_I, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 251; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_4 = PyTuple_New(1); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 251; goto __pyx_L1;}
+      Py_INCREF(__pyx_n_inf);
+      PyTuple_SET_ITEM(__pyx_4, 0, __pyx_n_inf);
+      __pyx_5 = PyObject_CallObject(((PyObject *)(&PyFloat_Type)), __pyx_4); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 251; goto __pyx_L1;}
+      Py_DECREF(__pyx_4); __pyx_4 = 0;
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_5;
+      __pyx_5 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_m, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_1 = PyInt_FromLong(((__pyx_v_argv[__pyx_3])->m[0])); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_4 = PyInt_FromLong(((__pyx_v_argv[__pyx_3])->m[1])); if (!__pyx_4) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_5 = PyInt_FromLong(((__pyx_v_argv[__pyx_3])->m[2])); if (!__pyx_5) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_7 = PyInt_FromLong(((__pyx_v_argv[__pyx_3])->m[3])); if (!__pyx_7) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      __pyx_8 = PyTuple_New(4); if (!__pyx_8) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; goto __pyx_L1;}
+      PyTuple_SET_ITEM(__pyx_8, 0, __pyx_1);
+      PyTuple_SET_ITEM(__pyx_8, 1, __pyx_4);
+      PyTuple_SET_ITEM(__pyx_8, 2, __pyx_5);
+      PyTuple_SET_ITEM(__pyx_8, 3, __pyx_7);
+      __pyx_1 = 0;
+      __pyx_4 = 0;
+      __pyx_5 = 0;
+      __pyx_7 = 0;
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_8;
+      __pyx_8 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_t, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+      __pyx_3 = PyInt_AsSsize_t(__pyx_v_i); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; goto __pyx_L1;}
+      __pyx_1 = PyFloat_FromDouble(__pyx_f_5liblo__timetag_to_double((__pyx_v_argv[__pyx_3])->t)); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; goto __pyx_L1;}
+      Py_DECREF(__pyx_v_v);
+      __pyx_v_v = __pyx_1;
+      __pyx_1 = 0;
+      goto __pyx_L4;
+    }
+    if (PyObject_Cmp(__pyx_v_t, __pyx_n_b, &__pyx_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 254; goto __pyx_L1;}
+    __pyx_6 = __pyx_6 == 0;
+    if (__pyx_6) {
+
+      /* "/home/rryan/Code/pyliblo-0.8.1/src/liblo.pyx":256 */