Metadata-Version: 1.1
Name: pycapnp
Version: 0.5.10
Summary: A cython wrapping of the C++ Cap'n Proto library
Home-page: https://github.com/jparyani/pycapnp
Author: Jason Paryani
Author-email: pypi-contact@jparyani.com
License: BSD
Download-URL: https://github.com/jparyani/pycapnp/archive/v0.5.10.zip
Description: pycapnp
        =======
        
        More thorough docs are available at http://jparyani.github.io/pycapnp/.
        
        Requirements
        ------------
        
        pycapnp's distribution has no requirements beyond a C++11 compatible
        compiler. GCC 4.8+ or Clang 3.3+ should work fine.
        
        pycapnp has additional development dependencies, including cython and
        py.test. See requirements.txt for them all.
        
        Building and installation
        -------------------------
        
        Install with ``pip install pycapnp``. You can set the CC environment
        variable to control which compiler is used, ie
        ``CC=gcc-4.8 pip install pycapnp``.
        
        Or you can clone the repo like so:
        
        ::
        
            git clone https://github.com/jparyani/pycapnp.git
            pip install --install-option '--force-cython' ./pycapnp
        
        Note: for OSX, if using clang from Xcode 5, you may need to set
        ``CFLAGS`` like so:
        
        ::
        
            CFLAGS='-stdlib=libc++' pip install pycapnp
        
        If you wish to install using the latest upstream C++ Cap'n Proto:
        
        ::
        
            pip install --install-option "--libcapnp-url" --install-option "https://github.com/sandstorm-io/capnproto/archive/master.tar.gz" --install-option "--force-bundled-libcapnp" .
        
        Python Versions
        ---------------
        
        Python 2.6/2.7 are supported as well as Python 3.2+. PyPy 2.1+ is also
        supported.
        
        One oddity to note is that ``Text`` type fields will be treated as byte
        strings under Python 2, and unicode strings under Python 3. ``Data``
        fields will always be treated as byte strings.
        
        Development
        -----------
        
        This project uses
        `git-flow <http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/>`__.
        Essentially, just make sure you do your changes in the ``develop``
        branch. You can run the tests by installing pytest with
        ``pip install pytest``, and then run ``py.test`` from the ``test``
        directory.
        
        Binary Packages
        ~~~~~~~~~~~~~~~
        
        In order to build binary packages from this source code, you must
        specify the ``--disable-cython`` option:
        
        Building a dumb binary distribution:
        
        ::
        
            python setup.py bdist_dumb --disable-cython
        
        Building a Python wheel distributiion:
        
        ::
        
            python setup.py bdist_wheel --disable-cython
        
        If it fails with an error like
        ``clang: error: no such file or directory: 'capnp/lib/capnp.cpp'``, then
        you need to cythonize fist. This can be done with:
        
        ::
        
            python setup.py build --force-cython
        
        Documentation/Example
        ---------------------
        
        There is some basic documentation
        `here <http://jparyani.github.io/pycapnp/>`__.
        
        The examples directory has one example that shows off pycapnp quite
        nicely. Here it is, reproduced:
        
        .. code:: python
        
            from __future__ import print_function
            import os
            import capnp
        
            import addressbook_capnp
        
            def writeAddressBook(file):
                addresses = addressbook_capnp.AddressBook.new_message()
                people = addresses.init('people', 2)
        
                alice = people[0]
                alice.id = 123
                alice.name = 'Alice'
                alice.email = 'alice@example.com'
                alicePhones = alice.init('phones', 1)
                alicePhones[0].number = "555-1212"
                alicePhones[0].type = 'mobile'
                alice.employment.school = "MIT"
        
                bob = people[1]
                bob.id = 456
                bob.name = 'Bob'
                bob.email = 'bob@example.com'
                bobPhones = bob.init('phones', 2)
                bobPhones[0].number = "555-4567"
                bobPhones[0].type = 'home'
                bobPhones[1].number = "555-7654"
                bobPhones[1].type = 'work'
                bob.employment.unemployed = None
        
                addresses.write(file)
        
        
            def printAddressBook(file):
                addresses = addressbook_capnp.AddressBook.read(file)
        
                for person in addresses.people:
                    print(person.name, ':', person.email)
                    for phone in person.phones:
                        print(phone.type, ':', phone.number)
        
                    which = person.employment.which()
                    print(which)
        
                    if which == 'unemployed':
                        print('unemployed')
                    elif which == 'employer':
                        print('employer:', person.employment.employer)
                    elif which == 'school':
                        print('student at:', person.employment.school)
                    elif which == 'selfEmployed':
                        print('self employed')
                    print()
        
        
            if __name__ == '__main__':
                f = open('example', 'w')
                writeAddressBook(f)
        
                f = open('example', 'r')
                printAddressBook(f)
        
        Also, pycapnp has gained RPC features that include pipelining and a
        promise style API. Refer to the calculator example in the examples
        directory for a much better demonstration:
        
        .. code:: python
        
            import capnp
            import socket
        
            import test_capability_capnp
        
        
            class Server(test_capability_capnp.TestInterface.Server):
        
                def __init__(self, val=1):
                    self.val = val
        
                def foo(self, i, j, **kwargs):
                    return str(i * 5 + self.val)
        
        
            def server(write_end):
                server = capnp.TwoPartyServer(write_end, bootstrap=Server(100))
        
        
            def client(read_end):
                client = capnp.TwoPartyClient(read_end)
        
                cap = client.bootstrap()
                cap = cap.cast_as(test_capability_capnp.TestInterface)
        
                remote = cap.foo(i=5)
                response = remote.wait()
        
                assert response.x == '125'
        
        
            if __name__ == '__main__':
                read_end, write_end = socket.socketpair(socket.AF_UNIX)
                # This is a toy example using socketpair.
                # In real situations, you can use any socket.
        
                server(write_end)
                client(read_end)
        
        Common Problems
        ---------------
        
        If you get an error on installation like:
        
        ::
        
            ...
            gcc-4.8: error: capnp/capnp.c: No such file or directory
        
            gcc-4.8: fatal error: no input files
        
        Then you have too old a version of setuptools. Run
        ``pip install -U setuptools`` then try again.
        
        |Build Status|
        
        .. |Build Status| image:: https://travis-ci.org/jparyani/pycapnp.png?branch=develop
           :target: https://travis-ci.org/jparyani/pycapnp
        
        Changelog
        =============
        v0.5.10 (2016-11-28)
        --------------------
        
        -  Fix bug that prevented event loop from actually being lazy
           initialized
        -  Fix possible recursive loop in KjException
        -  Add ``clear_write_flag`` method to builder classes
        
        v0.5.9 (2016-07-07)
        -------------------
        
        -  Make the event loop be lazy initialized
        -  Add support for segment (de)serialization (thanks to @gcv). See
           to\_segments/from\_segments methods.
        -  Fix response objects not referencing parents correctly
        -  Add test for large reads
        
        v0.5.8 (2016-05-27)
        -------------------
        
        -  Fix build problem with Cython v0.24
        -  Include the changelog in the manifest (should fix install problems if
           pandoc is present)
        -  Include the traceback in exceptions
        -  Make sure to encode to utf-8, not the default encoding (thanks to
           @novas0x2a)
        -  Add --libcapnp-url option in installer to allow installing arbitrary
           libcapnp versions
        -  Support mmap objects for reading with from\_bytes (thanks to
           @bpiwowar)
        -  Change read\_multiple and read\_multiple\_packed to copy by default
        -  Fix mistakenly discarding the file parameter on reads
        -  Add reraise\_kj\_exception to the prettyPrint functions. (thanks to
           @kdienes)
        -  Fix KjException init (missing wrapper). (thanks to @E8-Storage)
        -  Add ``result_type`` to InterfaceMethodSchema
        
        v0.5.7 (2015-06-16)
        -------------------
        
        -  Update bundled libcapnp to v0.5.2
        -  Add warnings for using old restorer methods. You should use
           ``bootstrap`` instead
        -  Fix warning from PyEventPort
        -  Handle AnyPointers better as arguments to RPC functions
        -  Add support for using keyword arguments with a named struct in an RPC
        -  Add bootstrap method to TwoPartyServer
        -  Add ``init`` method to lists
        -  Add support for unix sockets in RPC
        
        v0.5.6 (2015-04-13)
        -------------------
        
        -  Fix a serious bug in TwoPartyServer that was preventing it from
           working when passed a string address.
        -  Fix bugs that were exposed by defining KJDEBUG (thanks @davidcarne
           for finding this)
        
        v0.5.5 (2015-03-06)
        -------------------
        
        -  Update bundled C++ libcapnp to v0.5.1.2 security release
        
        v0.5.4 (2015-03-02)
        -------------------
        
        -  Update bundled C++ libcapnp to v0.5.1.1 security release
        -  Add bootstrap RPC methods
        -  Fix possible segfault when importing multiple schemas
        
        v0.5.3 (2015-02-23)
        -------------------
        
        -  Fix possible crash due to bad destructor ordering in MessageReader
           (by @JohnEmhoff)
        -  Default to no longer using cython
        
        v0.5.2 (2015-02-20)
        -------------------
        
        -  Add read\_multiple\_bytes/read\_multiple\_bytes\_packed methods
        -  Added Python 3.4 to the travis build matrix
        -  Bump version for bundled C++ libcapnp to v0.5.1
        
        v0.5.1 (2014-12-27)
        -------------------
        
        -  Remove installation dependency on cython. We now have no dependencies
           since libcapnp will automatically build as well.
        
        v0.5.0 (2014-12-15)
        -------------------
        
        -  Timer class ``capnp.getTimer()``
        -  pycapnp is now thread-safe and allows an event loop to be run in each
           thread
        -  You must destroy and re-create the event loop to get this
           functionality (see ``test_threads.py``)
        -  Inheritance now works correctly for interfaces (previously inherited
           methods were inaccessible from pycapnp)
        -  Add ability to import modules with dashes or spaces. Use underscores
           in place of them
        -  ``from_bytes`` with builder=True is no longer zero copy. It never
           worked correctly, and is much safer now
        -  Add ``num_first_segment_words`` argument wherever message creation
           can occur
        -  Allow restoring a null objectId by passing None to restore
        -  Support ordered dictionary in ``to_dict``
        -  Add ListSchema class and schemas for native types under
           ``capnp.types`` which completes all the Schemas needed to be wrapped.
           See ``test_schema.py`` for examples using it
        -  Add automatic build of C++ libcapnp if it's not detected on the
           system. Also add flags --force-bundled-libcapnp and
           --force-system-libcapnp respectively
        
        v0.4.6 (2014-9-10)
        ------------------
        
        -  Fix build for new 0.21 release of Cython. 0.21 is now the minimum
           supported version of Cython.
        
        v0.4.5 (2014-6-26)
        ------------------
        
        -  Fix ``to_dict`` not converting enums to strings
        
        v0.4.4 (2014-04-25)
        -------------------
        
        -  Fix compilation problem with gcc 4.8
        
        v0.4.3 (2014-02-18)
        -------------------
        
        -  Fix problem with uninitialized unions in \_from\_dict
        -  Add accesible version numbers for C++ libcapnp
        
        v0.4.2 (2014-02-13)
        -------------------
        
        -  Remove onDrained since it was removed upstream
        -  Replace usage of strings as enum type with custom ``_DynamicEnum``
           class.
        -  Also change ``Struct.which()`` method to be a property
           ``Struct.which`` and return an enum type (``_DynamicEnumField``,
           which behaves much like ``_DynamicEnum``).
        -  TwoPartyServer.run\_forever() now will handle more than 1
           simulataneous connection.
        -  Change exception wrapper to detect and raise AttributeError for field
           lookup exceptions (Fixes problem in Python3.x ``__dir__``)
        -  Allow setting of fields with python dicts.
        
        0.4.1 (2013-12-18)
        ------------------
        
        -  Remove python 3.2 from travis tests. Python 3.2 still should work
           fine, but it's more trouble than it's worth to write unicode tests
           that work in both it and Python2.
        -  Fix problems with null characters in Text/Data fields. Fixes #19
        
        0.4.0 (2013-12-12)
        ------------------
        
        -  Initial working version of RPC
        -  Add get\_root\_as\_any to \_MessageReader
        -  Add capnp.pxd for public declarations of cython classes
        -  Fix problems compiling with gcc4.7
        
        v0.3.18 (2013-11-05)
        --------------------
        
        -  Change naming of ReaderOption parameters to be pep8 compliant
        
        v0.3.17 (2013-11-05)
        --------------------
        
        -  Add ReaderOptions to read/read\_packed/from\_bytes
        
        v0.3.16 (2013-10-28)
        --------------------
        
        -  Add defaults flag to capnp-json. Also remove 'which' field
        -  Add capnp-json serializer script. Also fix bugs in from\_dict
        -  Fix build for clang/python3. Also remove -fpermissive
        -  Add ``as_builder`` method to Struct Reader
        -  Add warning when writing the same message more than once
        -  First working version of capability interfaces
        -  Wrap InterfaceSchema
        -  Fix setting string fields to support all types of strings
        -  Fix changed API for DynamicObject/ObjectPointer
        
        v0.3.15 (2013-09-19)
        --------------------
        
        -  Add not having installed the C++ libcapnp library to 'Common
           Problems'
        -  Add \_short\_str function for use in capnp\_test\_pycapnp.py
        -  Add test script for testing with https://github.com/kaos/capnp\_test
        -  Add handling of DynamicObject
        -  Fix lists of lists or dicts for from\_dict
        
        v0.3.14 (2013-09-04)
        --------------------
        
        -  Fix problem with to\_dict
        
        v0.3.13 (2013-09-04)
        --------------------
        
        -  Add \_DynamicStructBuilder.to\_bytes() and .from\_bytes()
        -  Change == on StructSchema to return cbool
        -  Add Builder and Reader ABCs for each struct type
        
        v0.3.12 (2013-09-03)
        --------------------
        
        -  Fix handling of empty path '' in load\_module
        -  Add from\_dict
        -  Fix bug in exception handling for which(). Also standardize
           exceptions.
        -  Change import hook to require modules to end in '\_capnp'
        -  Add import monkey patch function.
        -  Change naming for functions to conform to PEP 8. Also deprecate old
           read/write API
        -  Update preferred method for reading/writing messages from files
        
        v0.3.11 (2013-09-01)
        --------------------
        
        -  Forgot to change project name in setup.py
        
        v0.3.10 (2013-09-01)
        --------------------
        
        -  Change all references to old project name (change from
           capnpc-python-cpp to pycapnp)
        -  Change DynamicValue.Reader lists to be returned as
           \_DynamicListReader
        -  Unify setters for DynamicList and DynamicStruct
        -  Add shortcuts for reading from / writing to files. In Python, it
           doesn't make much sense to force people to muck around with
           MessageReaders and MessageBuilders since everything is landing on the
           heap anyway. Instead, let's make it easy:
           MyType.read[Packed]From(file) reads a file and returns a MyType
           reader. MyType.newMessage() returns a MyType builder representing the
           root of a new message. You can call this builder's
           write[Packed]To(file) method to write it to a file.
        -  Store Builders by value rather than allocate them separately on the
           heap (matches treatment of Readers). v0.3 fixes the bug that made
           this not work.
        -  Wrap MessageBuilder::setRoot().
        -  Add tests based on TestAllTypes from the C++ test.capnp. Fix problems
           uncovered in capnp.pyx.
        -  Implement **str** and **repr** for struct and list builders. **str**
           uses prettyPrint while **repr** shows the type name and the
           low-whitespace stringification. Also implement **repr** for
           StructSchema, just because why not?
        
        v0.3.9 (2013-08-30)
        -------------------
        
        -  Change load to use a global SchemaParser. Make structs settable as
           field
        -  Add docstrings for new functions and \_DynamicResizableListBuilder
        
        v0.3.8 (2013-08-29)
        -------------------
        
        -  Add initial tests
        -  Add \_capnp for original Cython module. Meant for testing.
        -  Lowercase schema so it conforms to member naming conventions
        -  Expose \_StructSchema's raw node
        -  Add some useful \_StructSchema, reader, and builder methods
        -  Add full orphan functionality. Also, allow special orphan lists
        -  Finish up adding docstrings to all public classes/methods
        
        v0.3.7 (2013-08-26)
        -------------------
        
        -  Add a ton of docstrings and add to official docs
        -  Add DynamicOrphan
        
        v0.3.6 (2013-08-26)
        -------------------
        
        -  Add intersphinx for linking to python docs
        -  Add C++ library version check
        
        v0.3.5 (2013-08-25)
        -------------------
        
        -  Add handling of constants in schemas
        -  Fix new error with DynamicValue.Builder no longer being copyable
        
        v0.3.4 (2013-08-22)
        -------------------
        
        -  Fix Void namespace change
        -  Updated capnp schema to conform with new union rules
        
        v0.3.3 (2013-08-22)
        -------------------
        
        -  Fix for the removal of DynamicUnion from the C++ API
        
        v0.3.2 (2013-08-21)
        -------------------
        
        -  Add MANIFEST.in to include README
        
        v0.3.1 (2013-08-21)
        -------------------
        
        -  Update docs with lines about upgrading setuptools
        
        0.3.0 (2013-08-21)
        ------------------
        
        -  Initial commit of docs
        -  Add querying unnamed enums to structs
        
        0.2.1 (2013-08-13)
        ------------------
        
        -  Fix enum interface change for benchmark
        -  Random formatting cleanup
        -  Allow import paths in the schema loader
        -  Add travis CI
        
        0.2.0 (2013-08-12)
        ------------------
        
        -  Initial working version
        
Keywords: capnp,capnproto,Cap'n Proto
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: POSIX
Classifier: Programming Language :: C++
Classifier: Programming Language :: Cython
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Communications
