Metadata-Version: 1.1
Name: pseud
Version: 1.0.1
Summary: Bidirectionnal RPC Api on top of pyzmq
Home-page: https://github.com/ticosax/pseud
Author: Nicolas Delaby
Author-email: ticosax@free.fr
License: Apache Software License
Description: pseud
        =====
        .. image:: https://travis-ci.org/ticosax/pseud.svg?branch=master
           :target: https://travis-ci.org/ticosax/pseud
           :alt: Travis-CI Status
        
        .. image:: https://codecov.io/gh/ticosax/pseud/branch/master/graph/badge.svg
           :target: https://codecov.io/gh/ticosax/pseud
           :alt: Coverage Status
        
        .. image:: https://readthedocs.org/projects/pseud/badge/?version=latest
           :target: http://pseud.readthedocs.io/en/latest/?badge=latest
           :alt: Documentation Status
        
        Pythonic bidirectional-rpc API built on top of ØMQ with pluggable
        encryption, authentication and heartbeating support.
        
        Features
        ~~~~~~~~
        #. ØMQ transport layer.
        #. All native python types supported (msgpack).
        #. First citizen exceptions.
        #. Bi-bidirectional (server can initiate calls to connected clients).
        #. Encryption based on CURVE.
        #. Pluggable Authentication.
        #. Pluggable Heartbeating.
        #. Pluggable Remote Call Routing.
        #. Built-in proxy support. A server can delegate the work to another one.
        #. SyncClient (using zmq.REQ) to use within non event based processes.
           (Heartbeating, Authentication and job execution are not supported with
           the SyncClient.)
        
        Installation
        ~~~~~~~~~~~~
        
        .. code-block:: console
        
           $ pip install pseud
        
        
        Execution
        ~~~~~~~~~
        
        The Server
        ------------------
        
        .. code-block:: python
        
            from pseud import Server
        
        
            server = Server('service')
            server.bind('tcp://127.0.0.1:5555')
        
            @server.register_rpc
            def hello(name):
                return 'Hello {0}'.format(name)
        
            await server.start()  # this will block forever
        
        
        The Client
        ------------------
        
        .. code-block:: python
        
            from pseud import Client
        
        
            client = Client('service', io_loop=loop)
            client.connect('tcp://127.0.0.1:5555')
        
            # Assume we are inside a coroutine
            async with client:
                response = await client.hello('Charly')
                assert response == 'Hello Charly'
        
        
        
        The SyncClient
        --------------
        
        .. code-block:: python
        
           # to use within a non-asynchronous process or in a command interpreter
           from pseud import SyncClient
        
        
           client = SyncClient()
           client.connect('tcp://127.0.0.1:5555')
        
           assert client.hello('Charly') == 'Hello Charly'
        
        
        
        The Server send a command to the client
        ---------------------------------------
        
        It is important to note that the server needs to know which
        peers are connected to it.
        This is why the security_plugin ``trusted_peer`` comes handy.
        It will register all peer id and be able to route messages to each of them.
        
        .. code-block:: python
        
           from pseud import Server
        
        
           server = Server('service', security_plugin='trusted_peer')
           server.bind('tcp://127.0.0.1:5555')
        
           @server.register_rpc
           def hello(name):
               return 'Hello {0}'.format(name)
        
           await server.start()  # this will block forever
        
        The client needs to send its identity to the server. This is why ``plain``
        security plugin is used. The server will not check the password, he will just
        take into consideration the user_id to perform the routing.
        
        
        .. code-block:: python
        
           from pseud import Client
        
        
           client = Client('service',
                           security_plugin='plain',
                           user_id='alice',
                           password='')
           client.connect('tcp://127.0.0.1:5555')
        
           # Action that the client will perform when
           # requested by the server.
           @client.register_rpc(name='draw.me.a.sheep')
           def sheep():
               return 'beeeh'
        
        
        Back on server side, we can send to it any commands the client is able to do.
        
        .. code-block:: python
        
            # assume we are inside a coroutine
            sheep = await server.send_to('alice').draw.me.a.sheep()
            assert sheep == 'beeeh'
        
        
        Documentation
        ~~~~~~~~~~~~~
        `Pseud on Readthedocs <https://pseud.readthedocs.io/en/latest/index.html>`_
        
        Copyright 2014 ezeep GmbH
        
        Licensed under the Apache License, Version 2.0 (the "License");
        you may not use this file except in compliance with the License.
        You may obtain a copy of the License at
        
            http://www.apache.org/licenses/LICENSE-2.0
        
        Unless required by applicable law or agreed to in writing, software
        distributed under the License is distributed on an "AS IS" BASIS,
        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
        See the License for the specific language governing permissions and
        limitations under the License.
        
Keywords: rpc zeromq pyzmq curve bidirectional asyncio
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: System Administrators
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3.6
