Python Client Examples

Example #1

    def test_data_is_not_bytes(self):
        client = Client()
        client.connect_local(port=7050)
        push = client.push()

        with pytest.raises(TypeError):
            push(u'msg')

Example #2

File: test_client_server.py Project: jkhoogland/python-zeroless

    def test_client_addresses_property(self):
        client = Client()
        addresses = (('10.0.0.1', 1567), ('10.0.0.2', 1568), ('10.0.0.3', 1569))

        for ip, port in addresses:
            client.connect(ip, port)

        assert client.addresses == addresses

Example #3

    def test_connection_already_exist(self):
        client = Client()
        client.connect_local(port=1024)

        with pytest.raises(ValueError):
            client.connect_local(port=1024)

        client.disconnect_local(port=1024)
        client.connect_local(port=1024)

Example #4

File: test_client_server.py Project: zmqless/python-zeroless

    def test_client_addresses_property(self):
        client = Client()
        addresses = (('10.0.0.1', 1567), ('10.0.0.2', 1568), ('10.0.0.3',
                                                              1569))

        for ip, port in addresses:
            client.connect(ip, port)

        assert client.addresses == addresses

Example #5

File: pubsub.py Project: vegetablejuiceftw/sauron

def get_listener(*channels: Channel):
    # Connects the client to as many servers as desired
    client = Client()

    # connect to all ports
    ports = sum([channel.ports for channel in channels], [])
    for port in ports:
        client.connect_local(port=port)

    # Assigns an iterable to wait for incoming messages with the topics
    return get_mapped_stream(client, *channels)

Example #6

    def test_there_was_no_connection_to_disconnect(self):
        client = Client()
        client.connect_local(port=1024)

        with pytest.raises(ValueError):
            client.disconnect_local(port=1025)

        client.disconnect_local(port=1024)

        with pytest.raises(ValueError):
            client.disconnect_local(port=1024)

Example #7

    def test_subscribed_topics_are_not_bytes(self):
        client = Client()
        client.connect_local(port=7099)

        client.sub(topics=[b'topic1'])

        with pytest.raises(TypeError):
            client.sub(topics=[u'topic1'])

        with pytest.raises(TypeError):
            client.sub(topics=[b'topic1', u'topic2'])

Example #8

 def test_port_on_range_cascaded(self):
     Client()\
     .connect_local(port=1024)\
     .disconnect_local(port=1024)\
     .connect_local(port=7000)\
     .disconnect_local(port=7000)\
     .connect_local(port=65535)\
     .disconnect_local(port=65535)

Example #9

 def test_disconnect_all_cascaded(self):
     Client()\
     .connect_local(port=1024)\
     .connect_local(port=1025)\
     .connect_local(port=1026)\
     .connect_local(port=1027)\
     .disconnect_all()\
     .connect_local(port=1024)\
     .connect_local(port=1025)\
     .connect_local(port=1026)\
     .connect_local(port=1027)

Example #10

    def test_port_under_range(self):
        client = Client()
        with pytest.raises(ValueError):
           client.connect_local(port=1023)

        with pytest.raises(ValueError):
           client.disconnect_local(port=1023)

        with pytest.raises(ValueError):
            Server(port=1023)

Example #11

File: test_pubsub.py Project: davinirjr/zeroless

def listen_for_pub_with_empty_topic():
    client = Client()
    client.connect(ip='127.0.0.1', port=7895)
    return client.sub()

Example #12

File: test_reqrep.py Project: davinirjr/zeroless

def request_gens():
    client = Client()
    client.connect_local(port=7892)
    return client.request()

Example #13

File: DeviceManager.py Project: AuraMiddleware/aura-middleware

from aura.managers import StorageManager as db
from aura.managers import SemanticManager as graph
from zeroless import Client, Server
from aura.managers import helpers
import json

zmq_broker = Client()
zmq_broker.connect_local(port=helpers.ports["broker"])
push_to_broker = zmq_broker.push()

zmq_task = Client()
zmq_task.connect_local(port=helpers.ports["task_manager"])
push_to_task = zmq_task.push()


def verify(collection, obj_id):
    return db.get(collection, obj_id) != None


def create(collection, obj):
    if not verify(collection, obj["@id"]):
        graph.parse(json.dumps(obj))
        db.store(collection, obj)
    else:
        print("Already have " + str(obj["@id"]) + " in database.")


def notify_unknown_object(obj_type, obj_id):
    obj = {}
    obj["id"] = obj_id
    obj["type"] = obj_type

Example #14

File: reqRepClient.py Project: davinirjr/zeroless

from zeroless import Client

# Connects the client to as many servers as desired
client = Client()
client.connect_local(port=12345)

# Initiate a request client
# And assigns a callable and an iterable
# To both transmit and wait for incoming messages
request, listen_for_reply = client.request()

for id, msg in [(b"1", b"Msg1"), (b"2", b"Msg2"), (b"3", b"Msg3")]:
    request(id, msg)
    response = next(listen_for_reply)
    print(response)

Example #15

File: pushPullClient.py Project: davinirjr/zeroless

import logging

from zeroless import (Client, log)

# Setup console logging
consoleHandler = logging.StreamHandler()
log.setLevel(logging.DEBUG)
log.addHandler(consoleHandler)

# Connects the client to as many servers as desired
client = Client()
client.connect_local(port=12345)

# Initiate a push client
# And assigns a callable to push messages
push = client.push()

for msg in [b"Msg1", b"Msg2", b"Msg3"]:
    push(msg)

Example #16

 def __build_watcher(self):
     client = Client()
     client.connect_local(port=self.PORT)
     return client

Example #17

    def test_pair_client_cannot_connect_more_than_once(self):
        client = Client()
        client.connect_local(port=7200)
        client.connect_local(port=7201)

        with pytest.raises(RuntimeError):
            client.pair()

        client = Client()
        client.connect_local(port=7200)

        client.pair()

        with pytest.raises(RuntimeError):
            client.connect_local(port=7201)

Example #18

File: test_pubsub.py Project: zmqless/python-zeroless

def listen_for_pub():
    client = Client()
    client.connect_local(port=7893)
    return client.sub()

Example #19

import logging

from zeroless import (Client, log)

# Setup console logging
consoleHandler = logging.StreamHandler()
log.setLevel(logging.DEBUG)
log.addHandler(consoleHandler)

# Connects the client to as many servers as desired
client = Client()
client.connect_local(port=12345)

# Initiate a subscriber client
# Assigns an iterable to wait for incoming messages with the topic 'sh'
listen_for_pub = client.sub(topics=[b'sh'])

for topic, msg in listen_for_pub:
    print(topic, ' - ', msg)

Example #20

File: test_pubsub.py Project: davinirjr/zeroless

def listen_for_pub_with_embedded_topic():
    client = Client()
    client.connect(ip='127.0.0.1', port=7894)
    return client.sub(topics=[b'sh'])

Example #21

File: test_pubsub.py Project: jkhoogland/python-zeroless

def listen_for_pub_with_embedded_topic():
    client = Client()
    client.connect_local(port=7894)
    return client.sub(topics=[b'sh'])

Example #22

File: pairClient.py Project: davinirjr/zeroless

from zeroless import Client

# Connects the client to a single server
client = Client()
client.connect_local(port=12345)

# Initiate a pair client
# And assigns a callable to transmit messages
pair, _ = client.pair()

for id, msg in [(b"1", b"Msg1"), (b"2", b"Msg2"), (b"3", b"Msg3")]:
    pair(id, msg)

Example #23

File: test_pubsub.py Project: jkhoogland/python-zeroless

def listen_for_pub_with_empty_topic():
    client = Client()
    client.connect_local(port=7896)
    return client.sub()

Example #24

File: test_pubsub.py Project: zmqless/python-zeroless

def listen_for_pub_with_embedded_topic():
    client = Client()
    client.connect_local(port=7894)
    return client.sub(topics=[b'sh'])

Example #25

    def test_connection_after_pattern_was_established(self):
        client = Client()
        listen_for_push = client.pull()

        client.connect_local(port=1024)

        with pytest.raises(ValueError):
            client.connect_local(port=1024)

        client.disconnect_local(port=1024)

        with pytest.raises(ValueError):
            client.disconnect_local(port=1024)

Example #26

File: test_pubsub.py Project: zmqless/python-zeroless

def listen_for_pub_with_empty_topic():
    client = Client()
    client.connect_local(port=7896)
    return client.sub()

Example #27

File: aura_broker.py Project: viniciusmsfraga/aura-middleware

#!/usr/bin/env python3

from os import environ
import paho.mqtt.client as mqtt
from aura.managers import helpers
from zeroless import Client, Server


mqtt_broker_ip = environ['MQTT_BROKER_IP']
mqtt_port = int(environ['MQTT_PORT'])

zmq_client = Client()
zmq_client.connect_local(port=helpers.ports['device_manager'])
zmq_push = zmq_client.push()

def on_connect(client, userdata, flags, rc):
    print("Connected with result code "+str(rc))
    client.subscribe("gateways/test")


def on_message(client, userdata, msg):
    zmq_push(msg.payload)


client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect(mqtt_broker_ip, mqtt_port, 60)

#Listen for gateways' MQTT messages

Example #28

File: TaskManager.py Project: AuraMiddleware/aura-middleware

from zeroless import (Client, Server)
import json
from aura.managers import SemanticManager as graph
from aura.managers import StorageManager as db
from aura.managers import helpers

zmq_device = Client()
zmq_device.connect_local(port=helpers.ports['device_manager'])
push_to_device = zmq_device.push()

def create_condition(condition):
    print("create_condition")
    # TaskManager -> StorageManager
    db.store('conditions', condition)


def update_condition():
    # TaskManager -> StorageManager
    print("update_condition")


def remove_condition():
    # TaskManager -> StorageManager
    print("remove_condition")


def send_command(device, command):
    # TaskManager -> DeviceManager
    print("send_command")

Example #29

def push():
    client = Client()
    client.connect_local(port=7891)
    return client.push()

Example #30

File: test_pubsub.py Project: davinirjr/zeroless

def listen_for_pub_with_empty_topic():
    client = Client()
    client.connect(ip='127.0.0.1', port=7895)
    return client.sub()

Example #31

File: TaskManager.py Project: viniciusmsfraga/aura-middleware

from zeroless import (Client, Server)
import json
from aura.managers import SemanticManager as graph
from aura.managers import StorageManager as db
from aura.managers import helpers

zmq_device = Client()
zmq_device.connect_local(port=helpers.ports['device_manager'])
push_to_device = zmq_device.push()


def create_condition(condition):
    print("create_condition")
    # TaskManager -> StorageManager
    db.store('conditions', condition)


def update_condition():
    # TaskManager -> StorageManager
    print("update_condition")


def remove_condition():
    # TaskManager -> StorageManager
    print("remove_condition")


def send_command(device, command):
    # TaskManager -> DeviceManager
    print("send_command")

Example #32

 def test_port_on_range(self):
     client = Client()
     client.connect_local(port=1024)
     client.disconnect_local(port=1024)
     client.connect_local(port=7000)
     client.disconnect_local(port=7000)
     client.connect_local(port=65535)
     client.disconnect_local(port=65535)

Example #33

    def test_disconnect_all(self):
        client = Client()
        client.connect_local(port=1024)
        client.connect_local(port=1025)
        client.connect_local(port=1026)
        client.connect_local(port=1027)

        client.disconnect_all()

        client.connect_local(port=1024)
        client.connect_local(port=1025)
        client.connect_local(port=1026)
        client.connect_local(port=1027)

Example #34

File: pubSubServer.py Project: EnTeQuAk/python-zeroless

from zeroless import Client

# Connects the client to as many servers as desired
client = Client()
client.connect_local(port=12345)

# Initiate a subscriber client
# Assigns an iterable to wait for incoming messages with any topic
listen_for_pub = client.sub()

for topic, id, msg in listen_for_pub:
    print(topic, ' - ', id, ' - ', msg)

Example #35

File: test_pubsub.py Project: davinirjr/zeroless

def listen_for_pub_with_embedded_topic():
    client = Client()
    client.connect(ip='127.0.0.1', port=7894)
    return client.sub(topics=[b'sh'])

Example #36

File: test_pubsub.py Project: davinirjr/zeroless

def listen_for_pub():
    client = Client()
    client.connect_local(port=7893)
    return client.sub()

Example #37

File: DeviceManager.py Project: viniciusmsfraga/aura-middleware

from aura.managers import StorageManager as db
from aura.managers import SemanticManager as graph
from zeroless import (Client, Server)
from aura.managers import helpers
import json

zmq_broker = Client()
zmq_broker.connect_local(port=helpers.ports['broker'])
push_to_broker = zmq_broker.push()

zmq_task = Client()
zmq_task.connect_local(port=helpers.ports['task_manager'])
push_to_task = zmq_task.push()

def verify(collection, obj_id):
    return (db.get(collection, obj_id) != None)

def create(collection, obj):
    if not verify(collection, obj['@id']):
        graph.parse(json.dumps(obj))
        db.store(collection, obj)
    else:
        print("Already have " + str(obj['@id']) + " in database.")

def notify_unknown_object(obj_type, obj_id):
    obj = {}
    obj['id'] = obj_id
    obj['type'] = obj_type
    push_to_broker(json.dumps(obj).encode())

def send_command(device, command):

Example #38

File: test_pair.py Project: davinirjr/zeroless

def pair():
    client = Client()
    client.connect_local(port=7890)
    send, _ = client.pair()
    return send

Example #39

File: pairClient.py Project: davinirjr/zeroless

import logging

from zeroless import (Client, log)

# Setup console logging
consoleHandler = logging.StreamHandler()
log.setLevel(logging.DEBUG)
log.addHandler(consoleHandler)

# Connects the client to a single server
client = Client()
client.connect_local(port=12345)

# Initiate a pair client
# And assigns a callable and an iterable
# To both transmit and wait for incoming messages
pair, listen_for_pair = client.pair()

for msg in [b"Msg1", b"Msg2", b"Msg3"]:
    pair(msg)
    response = next(listen_for_pair)
    print(response)

Example #40

File: test_pushpull.py Project: EnTeQuAk/python-zeroless

def push():
    client = Client()
    client.connect_local(port=7891)
    return client.push()

Example #41

File: test_reqrep.py Project: EnTeQuAk/python-zeroless

def request_gens():
    client = Client()
    client.connect_local(port=7892)
    return client.request()