compas-eve 0.1.2__tar.gz

compas_eve-0.1.2/AUTHORS.md

@@ -0,0 +1,3 @@
+# Authors
+
+- Gonzalo Casas <<casas@arch.ethz.ch>> [@gonzalocasas](https://github.com/gonzalocasas)

compas_eve-0.1.2/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.2] 2023-07-09
+
+### Added
+
+### Changed
+
+### Removed
+
+
+## [0.1.1] 2023-07-09
+
+### Added
+
+### Changed
+
+### Removed
+

compas_eve-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Gramazio Kohler Research
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

compas_eve-0.1.2/MANIFEST.in

@@ -0,0 +1,22 @@
+graft src
+
+prune .github
+prune data
+prune docs
+prune scripts
+prune tests
+prune temp
+
+include LICENSE
+include README.md
+include AUTHORS.md
+include CHANGELOG.md
+include requirements.txt
+
+exclude requirements-dev.txt
+exclude pytest.ini .bumpversion.cfg .editorconfig
+exclude tasks.py
+exclude CONTRIBUTING.md
+exclude conftest.py
+
+global-exclude *.py[cod] __pycache__ *.dylib *.nb[ic] .DS_Store

compas_eve-0.1.2/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.1
+Name: compas_eve
+Version: 0.1.2
+Summary: COMPAS Event Extensions: adds event-based communication infrastructure to the COMPAS framework.
+Home-page: https://github.com/compas-dev/compas_eve
+Author: Gonzalo Casas
+Author-email: casas@arch.ethz.ch
+License: MIT license
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+
+# compas_eve
+
+COMPAS Event Extensions: adds event-based communication infrastructure to the COMPAS framework.
+
+
+## Getting started with this project
+
+### Setup code editor
+
+1. Open project folder in VS Code
+2. Select python environment for the project
+3. First time using VS Code and on Windows? Make sure select the correct terminal profile: `Ctrl+Shift+P`, `Terminal: Select Default Profile` and select `Command Prompt`.
+
+> All terminal commands in the following sections can be run from the VS Code integrated terminal. 
+
+
+### First steps with git
+
+1. Go to the `Source control` tab
+2. Make an initial commit with all newly created files
+
+
+### First steps with code
+
+1. Install the newly created project 
+
+        pip install -e .
+
+2. Install it on Rhino
+
+        python -m compas_rhino.install
+
+
+### Code conventions
+
+Code convention follows [PEP8](https://pep8.org/) style guidelines and line length of 120 characters.
+
+1. Check adherence to style guidelines
+
+        invoke lint
+
+2. Format code automatically
+
+        invoke format
+
+
+### Documentation
+
+Documentation is generated automatically out of docstrings and [RST](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html) files in this repository
+
+1. Generate the docs
+
+        invoke docs
+
+2. Check links in docs are valid
+
+        invoke linkcheck
+
+3. Open docs in your browser (file explorer -> `dist/docs/index.html`)
+
+
+### Testing
+
+Tests are written using the [pytest](https://docs.pytest.org/) framework
+
+1. Run all tests from terminal
+
+        invoke test
+
+2. Or run them from VS Code from the `Testing` tab
+
+
+### Developing Grasshopper components
+
+We use [Grasshopper Componentizer](https://github.com/compas-dev/compas-actions.ghpython_components) to develop Python components that can be stored and edited on git.
+
+1. Build components
+
+        invoke build-ghuser-components
+
+2. Install components on Rhino
+
+        python -m compas_rhino.install
+
+
+### Publish release
+
+Releases follow the [semver](https://semver.org/spec/v2.0.0.html) versioning convention.
+
+1. Create a new release
+
+        invoke release major

compas_eve-0.1.2/README.md

@@ -0,0 +1,92 @@
+# compas_eve
+
+COMPAS Event Extensions: adds event-based communication infrastructure to the COMPAS framework.
+
+
+## Getting started with this project
+
+### Setup code editor
+
+1. Open project folder in VS Code
+2. Select python environment for the project
+3. First time using VS Code and on Windows? Make sure select the correct terminal profile: `Ctrl+Shift+P`, `Terminal: Select Default Profile` and select `Command Prompt`.
+
+> All terminal commands in the following sections can be run from the VS Code integrated terminal. 
+
+
+### First steps with git
+
+1. Go to the `Source control` tab
+2. Make an initial commit with all newly created files
+
+
+### First steps with code
+
+1. Install the newly created project 
+
+        pip install -e .
+
+2. Install it on Rhino
+
+        python -m compas_rhino.install
+
+
+### Code conventions
+
+Code convention follows [PEP8](https://pep8.org/) style guidelines and line length of 120 characters.
+
+1. Check adherence to style guidelines
+
+        invoke lint
+
+2. Format code automatically
+
+        invoke format
+
+
+### Documentation
+
+Documentation is generated automatically out of docstrings and [RST](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html) files in this repository
+
+1. Generate the docs
+
+        invoke docs
+
+2. Check links in docs are valid
+
+        invoke linkcheck
+
+3. Open docs in your browser (file explorer -> `dist/docs/index.html`)
+
+
+### Testing
+
+Tests are written using the [pytest](https://docs.pytest.org/) framework
+
+1. Run all tests from terminal
+
+        invoke test
+
+2. Or run them from VS Code from the `Testing` tab
+
+
+### Developing Grasshopper components
+
+We use [Grasshopper Componentizer](https://github.com/compas-dev/compas-actions.ghpython_components) to develop Python components that can be stored and edited on git.
+
+1. Build components
+
+        invoke build-ghuser-components
+
+2. Install components on Rhino
+
+        python -m compas_rhino.install
+
+
+### Publish release
+
+Releases follow the [semver](https://semver.org/spec/v2.0.0.html) versioning convention.
+
+1. Create a new release
+
+        invoke release major

compas_eve-0.1.2/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.black]
+line-length = 120
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = ["tests"]
+python_files = [
+    "test_*.py",
+    "tests.py"
+]
+addopts = "-ra --strict --doctest-modules --doctest-glob=*.rst --tb=short"
+doctest_optionflags= "NORMALIZE_WHITESPACE IGNORE_EXCEPTION_DETAIL ALLOW_UNICODE ALLOW_BYTES NUMBER"
+filterwarnings = "ignore::DeprecationWarning"
+
+[tool.isort]
+line_length = 120
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+force_single_line = true
+ensure_newline_before_comments = true
+known_first_party = "compas_eve"
+default_section = "THIRDPARTY"
+forced_separate = "test_compas_eve"
+skip = ["__init__.py"]
+

compas_eve-0.1.2/requirements.txt

@@ -0,0 +1,2 @@
+compas
+paho-mqtt

compas_eve-0.1.2/setup.cfg

@@ -0,0 +1,18 @@
+[bdist_wheel]
+universal = 1
+
+[flake8]
+max-line-length = 120
+exclude = */migrations/*
+
+[doc8]
+max-line-length = 120
+ignore = D001
+
+[pydocstyle]
+convention = numpy
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

compas_eve-0.1.2/setup.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+# flake8: noqa
+from __future__ import absolute_import
+from __future__ import print_function
+
+import io
+from os import path
+
+from setuptools import setup
+from setuptools.command.develop import develop
+from setuptools.command.install import install
+
+
+here = path.abspath(path.dirname(__file__))
+
+
+def read(*names, **kwargs):
+    return io.open(path.join(here, *names), encoding=kwargs.get("encoding", "utf8")).read()
+
+
+long_description = read("README.md")
+requirements = read("requirements.txt").split("\n")
+optional_requirements = {}
+
+setup(
+    name="compas_eve",
+    version="0.1.2",
+    description="COMPAS Event Extensions: adds event-based communication infrastructure to the COMPAS framework.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/compas-dev/compas_eve",
+    author="Gonzalo Casas",
+    author_email="casas@arch.ethz.ch",
+    license="MIT license",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Scientific/Engineering",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: Unix",
+        "Operating System :: POSIX",
+        "Operating System :: Microsoft :: Windows",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: Implementation :: CPython",
+    ],
+    keywords=[],
+    project_urls={},
+    packages=["compas_eve"],
+    package_dir={"": "src"},
+    package_data={},
+    data_files=[],
+    include_package_data=True,
+    zip_safe=False,
+    install_requires=requirements,
+    python_requires=">=3.8",
+    extras_require=optional_requirements,
+    entry_points={
+        "console_scripts": [],
+    },
+    ext_modules=[],
+)

compas_eve-0.1.2/src/compas_eve/__init__.py

@@ -0,0 +1,46 @@
+"""
+********************************************************************************
+compas_eve
+********************************************************************************
+
+.. currentmodule:: compas_eve
+
+
+.. toctree::
+    :maxdepth: 1
+
+
+"""
+
+from __future__ import print_function
+
+import os
+
+
+__author__ = ["Gonzalo Casas"]
+__copyright__ = "Gramazio Kohler Research"
+__license__ = "MIT License"
+__email__ = "casas@arch.ethz.ch"
+__version__ = "0.1.2"
+
+from .event_emitter import EventEmitterMixin  # noqa: F401 needed here to avoid circular import on py2.7
+from .core import Message, Publisher, Subscriber, Transport, Topic, get_default_transport, set_default_transport
+from .memory import InMemoryTransport
+
+HERE = os.path.dirname(__file__)
+HOME = os.path.abspath(os.path.join(HERE, "../../"))
+
+set_default_transport(InMemoryTransport())
+
+__all__ = [
+    "HOME",
+    "Message",
+    "Publisher",
+    "Subscriber",
+    "Topic",
+    "Transport",
+    "get_default_transport",
+    "set_default_transport",
+    "InMemoryTransport",
+]
+__all_plugins__ = ["compas_eve.rhino.install"]

compas_eve-0.1.2/src/compas_eve/__main__.py

@@ -0,0 +1,2 @@
+if __name__ == "__main__":
+    pass

compas_eve-0.1.2/src/compas_eve/core.py

@@ -0,0 +1,155 @@
+import json
+
+# Python 2/3 compatibility import list
+try:
+    from collections import UserDict
+except ImportError:
+    from UserDict import UserDict
+
+DEFAULT_TRANSPORT = None
+
+
+def get_default_transport():
+    return DEFAULT_TRANSPORT
+
+
+def set_default_transport(transport):
+    global DEFAULT_TRANSPORT
+    DEFAULT_TRANSPORT = transport
+
+
+class MessageEncoder(json.JSONEncoder):
+    """Internal class to serialize some of the core data types into json."""
+
+    def default(self, o):
+        return super(MessageEncoder, self).default(o)
+
+
+class Transport(object):
+    """Defines the base interface for different transport implementations."""
+
+    def __init__(self, *args, **kwargs):
+        super(Transport, self).__init__(*args, **kwargs)
+        self._id_counter = 0
+
+    @property
+    def id_counter(self):
+        """Generate an auto-incremental ID starting from 1."""
+        self._id_counter += 1
+        return self._id_counter
+
+    def publish(self, topic, message):
+        pass
+
+    def subscribe(self, topic, callback):
+        pass
+
+    def unsubscribe(self, topic):
+        pass
+
+    def advertise(self, topic):
+        pass
+
+    def unadvertise(self, topic):
+        pass
+
+
+class Message(UserDict):
+    """Message objects used for publishing and subscribing to/from topics.
+
+    A message is fundamentally a dictionary and behaves as one."""
+
+    def __getattr__(self, name):
+        return self.data[name]
+
+    @classmethod
+    def parse(cls, value):
+        instance = cls()
+        instance.update(value)
+        return instance
+
+
+class Topic(object):
+    """Describes a topic"""
+
+    def __init__(self, name, message_type, **options):
+        self.name = name
+        self.message_type = message_type
+        self.options = options
+
+
+class Publisher(object):
+    """Publisher interface."""
+
+    def __init__(self, topic, transport=None):
+        self.topic = topic
+        self.transport = transport or get_default_transport()
+        self._advertise_id = None
+
+    @property
+    def is_advertised(self):
+        """Indicate if the publisher has announce its topic as advertised or not.
+
+        Returns:
+            bool: True if advertised as publisher of this topic, False otherwise.
+        """
+        return self._advertise_id is not None
+
+    def message_published(self, message):
+        """Handler called when a message has been published."""
+        pass
+
+    def publish(self, message):
+        """Publish a message to a topic."""
+        # TODO: check if message type matches self.topic.message_type declared
+        if not self.is_advertised:
+            self.advertise()
+
+        self.transport.publish(self.topic, message)
+        self.message_published(message)
+
+    def advertise(self):
+        if self.is_advertised:
+            return
+
+        self._advertise_id = self.transport.advertise(self.topic)
+
+    def unadvertise(self):
+        if not self.is_advertised:
+            return
+
+        self.transport.unadvertise(self.topic)
+        self._advertise_id = None
+
+
+class Subscriber(object):
+    """Subscriber interface."""
+
+    def __init__(self, topic, transport=None):
+        self.transport = transport or get_default_transport()
+        self.topic = topic
+        self._subscribe_id = None
+
+    # This is basically an abstract method that needs to be implemented in subclasses
+    # It's not really marked as such because IronPython causes a huge memory leak in these cases
+    def message_received(self, message):
+        pass
+
+    @property
+    def is_subscribed(self):
+        """Indicate if the instace is currently subscribed to its topic or not."""
+        return self._subscribe_id is not None
+
+    def subscribe(self):
+        if self._subscribe_id:
+            return
+
+        self._subscribe_id = self.transport.subscribe(self.topic, self.message_received)
+
+    def unsubscribe(self):
+        """Unregister the subscriber from its topic."""
+        if not self._subscribe_id:
+            return
+
+        self.transport.unsubscribe(self.topic)
+        self._subscribe_id = None

compas_eve-0.1.2/src/compas_eve/event_emitter.py

@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+
+# The following code is derivative work of [pyee](https://github.com/jfhbrook/pyee)
+# Copyrighted by Joshua Holbrook with a MIT license
+
+
+# The MIT License(MIT)
+
+# Copyright(c) 2015 Joshua Holbrook
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files(the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""
+``EventEmitterMixin`` is similar to the ``EventEmitter`` of Node.js.
+It supports both synchronous callbacks and asyncio coroutines.
+"""
+
+try:
+    from asyncio import ensure_future
+    from asyncio import iscoroutine
+except ImportError:
+    iscoroutine = None
+    ensure_future = None
+
+from collections import OrderedDict
+from collections import defaultdict
+from threading import RLock
+
+__all__ = ["EventEmitterMixin", "EventEmitterException"]
+
+
+class EventEmitterException(Exception):
+    """An internal exception."""
+
+    pass
+
+
+class EventEmitterMixin(object):
+    """Mixin to add event emitter features to a class.
+
+    For interoperation with asyncio, one can specify the scheduler and
+    the event loop. The scheduler defaults to ``asyncio.ensure_future``,
+    and the loop defaults to ``None``. When used with the default scheduler,
+    this will schedule the coroutine onto asyncio's default loop.
+
+    This should also be compatible with recent versions of twisted by
+    setting ``scheduler=twisted.internet.defer.ensureDeferred``.
+
+    Most events are registered with EventEmitterMixin via the ``on`` and ``once``
+    methods. However, event emitters have two *special* events:
+
+    - ``new_listener``: Fires whenever a new listener is created. Listeners for
+      this event do not fire upon their own creation.
+
+    - ``error``: When emitted raises an Exception by default, behavior can be
+      overriden by attaching callback to the event.
+
+      For example::
+
+          @ee.on('error')
+          def onError(message):
+              logging.err(message)
+
+          ee.emit('error', Exception('something blew up'))
+
+      For synchronous callbacks, exceptions are **not** handled for you---
+      you must catch your own exceptions inside synchronous ``on`` handlers.
+      However, when wrapping **async** functions, errors will be intercepted
+      and emitted under the ``error`` event. **This behavior for async
+      functions is inconsistent with node.js**, which unlike this package has
+      no facilities for handling returned Promises from handlers.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(EventEmitterMixin, self).__init__(*args, **kwargs)
+        self._events = defaultdict(OrderedDict)
+        self._schedule = kwargs.get("scheduler", ensure_future)
+        self._loop = kwargs.get("loop", None)
+        self._event_lock = RLock()
+
+    def on(self, event, f=None):
+        """Registers the function (or optionally an asyncio coroutine function)
+        ``f`` to the event name ``event``.
+
+        If ``f`` isn't provided, this method returns a function that
+        takes ``f`` as a callback; in other words, you can use this method
+        as a decorator, like so::
+
+            @ee.on('data')
+            def data_handler(data):
+                print(data)
+
+        As mentioned, this method can also take an asyncio coroutine function::
+
+           @ee.on('data')
+           async def data_handler(data)
+               await do_async_thing(data)
+
+
+        This will automatically schedule the coroutine using the configured
+        scheduling function (defaults to ``asyncio.ensure_future``) and the
+        configured event loop (defaults to ``asyncio.get_event_loop()``).
+
+        In both the decorated and undecorated forms, the event handler is
+        returned. The upshot of this is that you can call decorated handlers
+        directly, as well as use them in remove_listener calls.
+        """
+
+        with self._event_lock:
+
+            def _on(f):
+                self._add_event_handler(event, f, f)
+                return f
+
+            if f is None:
+                return _on
+            else:
+                return _on(f)
+
+    def _add_event_handler(self, event, k, v):
+        # Fire 'new_listener' *before* adding the new listener!
+        self.emit("new_listener", event, k)
+
+        # Add the necessary function
+        # Note that k and v are the same for `on` handlers, but
+        # different for `once` handlers, where v is a wrapped version
+        # of k which removes itself before calling k
+        self._events[event][k] = v
+
+    def emit(self, event, *args, **kwargs):
+        """Emit ``event``, passing ``*args`` and ``**kwargs`` to each attached
+        function. Returns ``True`` if any functions are attached to ``event``;
+        otherwise returns ``False``.
+
+        Example::
+
+            ee.emit('data', '00101001')
+
+        Assuming ``data`` is an attached function, this will call
+        ``data('00101001')'``.
+
+        For coroutine event handlers, calling emit is non-blocking. In other
+        words, you do not have to await any results from emit, and the
+        coroutine is scheduled in a fire-and-forget fashion.
+        """
+        handled = False
+
+        with self._event_lock:
+            for f in list(self._events[event].values()):
+                result = f(*args, **kwargs)
+
+                # If f was a coroutine function, we need to schedule it and
+                # handle potential errors
+                if iscoroutine and iscoroutine(result):
+                    if self._loop:
+                        d = self._schedule(result, loop=self._loop)
+                    else:
+                        d = self._schedule(result)
+
+                    # scheduler gave us an asyncio Future
+                    if hasattr(d, "add_done_callback"):
+
+                        @d.add_done_callback
+                        def _callback(f):
+                            exc = f.exception()
+                            if exc:
+                                self.emit("error", exc)
+
+                    # scheduler gave us a twisted Deferred
+                    elif hasattr(d, "addErrback"):
+
+                        @d.addErrback
+                        def _callback(exc):
+                            self.emit("error", exc)
+
+                handled = True
+
+        if not handled and event == "error":
+            if args:
+                raise args[0]
+            else:
+                raise EventEmitterException("Uncaught, unspecified 'error' event.")
+
+        return handled
+
+    def once(self, event, f=None):
+        """The same as ``ee.on``, except that the listener is automatically
+        removed after being called.
+        """
+
+        with self._event_lock:
+
+            def _wrapper(f):
+                def g(*args, **kwargs):
+                    self.remove_listener(event, f)
+                    # f may return a coroutine, so we need to return that
+                    # result here so that emit can schedule it
+                    return f(*args, **kwargs)
+
+                self._add_event_handler(event, f, g)
+                return f
+
+            if f is None:
+                return _wrapper
+            else:
+                return _wrapper(f)
+
+    def off(self, event, f):
+        """Removes the function ``f`` from ``event``."""
+        self._events[event].pop(f)
+
+    def remove_listener(self, event, f):
+        """Removes the function ``f`` from ``event``."""
+        self._events[event].pop(f)
+
+    def remove_all_listeners(self, event=None):
+        """Remove all listeners attached to ``event``.
+        If ``event`` is ``None``, remove all listeners on all events.
+        """
+        with self._event_lock:
+            if event is not None:
+                self._events[event] = OrderedDict()
+            else:
+                self._events = defaultdict(OrderedDict)
+
+    def listeners(self, event):
+        """Returns a list of all listeners registered to the ``event``."""
+        return list(self._events[event].keys())

compas_eve-0.1.2/src/compas_eve/memory/__init__.py

@@ -0,0 +1,52 @@
+from compas_eve.event_emitter import EventEmitterMixin
+from compas_eve.core import Transport
+
+
+class InMemoryTransport(Transport, EventEmitterMixin):
+    """In-Memory transport is ideal for simple single-process apps and testing.
+
+    It will only distribute messages within the same process, not across different processes."""
+
+    def __init__(self, *args, **kwargs):
+        super(InMemoryTransport, self).__init__(*args, **kwargs)
+
+    def on_ready(self, callback):
+        """In-memory transport is always ready, it will immediately trigger the callback."""
+        callback()
+
+    def publish(self, topic, message):
+        """Publish a message to a topic."""
+        event_key = "event_{}".format(topic.name)
+
+        def _callback(**kwargs):
+            self.emit(event_key, message)
+
+        self.on_ready(_callback)
+
+    def subscribe(self, topic, callback):
+        """Subscribe to be notified of messages on a given topic."""
+        event_key = "event_{}".format(topic.name)
+
+        def _callback(**kwargs):
+            self.on(event_key, callback)
+
+        self.on_ready(_callback)
+
+    def unsubscribe(self, topic):
+        """Unsubscribe from the specified topic."""
+        event_key = "event_{}".format(topic.name)
+        self.remove_all_listeners(event_key)
+
+    def advertise(self, topic):
+        """Announce this code will publish messages to the specified topic.
+
+        This call has no effect on the in-memory transport."""
+        advertise_id = "advertise:{}:{}".format(topic.name, self.id_counter)
+        # in-memory does not need anything here
+        return advertise_id
+
+    def unadvertise(self, topic):
+        """Announce this code will stop publishing messages to the specified topic.
+
+        This call has no effect on the in-memory transport."""
+        pass

compas_eve-0.1.2/src/compas_eve/mqtt/__init__.py

@@ -0,0 +1,8 @@
+import sys
+
+if sys.platform == "cli":
+    from .mqtt_cli import MqttTransport
+else:
+    from .mqtt_paho import MqttTransport
+
+__all__ = ["MqttTransport"]

compas_eve-0.1.2/src/compas_eve/mqtt/mqtt_cli.py

@@ -0,0 +1,107 @@
+# fmt: off
+from __future__ import print_function
+
+from ..core import MessageEncoder
+from ..core import Transport
+from ..event_emitter import EventEmitterMixin
+
+import clr
+import json
+import os
+import sys
+
+lib_dir = os.path.join(os.path.dirname(__file__), "netlib")
+if lib_dir not in sys.path:
+    sys.path.append(lib_dir)
+
+clr.AddReference("MQTTnet")
+
+from System import Action
+from System.Text import Encoding
+from System.Threading import CancellationToken, CancellationTokenSource, ManualResetEventSlim
+from System.Threading.Tasks import Task
+
+from MQTTnet import MqttFactory
+from MQTTnet import MqttApplicationMessageBuilder
+from MQTTnet.Client import MqttClientConnectResult
+from MQTTnet.Client import MqttClientConnectResultCode
+from MQTTnet.Client import MqttClientOptionsBuilder
+from MQTTnet.Client import MqttClientDisconnectOptionsBuilder
+
+
+class MqttTransport(Transport, EventEmitterMixin):
+    def __init__(self, host, port=1883, *args, **kwargs):
+        super(MqttTransport, self).__init__(*args, **kwargs)
+        self.host = host
+        self.port = port
+        self._is_connected = False
+        self.cancellation_token_source = CancellationTokenSource()
+        self.cancellation_token = self.cancellation_token_source.Token
+
+        self.factory = MqttFactory()
+        options = MqttClientOptionsBuilder().WithTcpServer(host, port).Build()
+
+        self.client = self.factory.CreateMqttClient()
+        self.client.ConnectAsync(options, self.cancellation_token).ContinueWith.Overloads[Action[Task[MqttClientConnectResult]]](self._on_connect)
+
+
+    def _on_connect(self, event_args):
+        if event_args.Result.ResultCode == MqttClientConnectResultCode.Success:
+            self._is_connected = event_args.Result.ResultCode == MqttClientConnectResultCode.Success
+            self.emit("ready")
+
+    def close(self):
+        options = MqttClientDisconnectOptionsBuilder().WithReasonString("Normal").Build()
+        self.client.DisconnectAsync(options, CancellationToken.None) # noqa: E999 (disable flake8 error, which incorrectly parses None as the python keyword)
+
+    def on_ready(self, callback):
+        if self._is_connected:
+            callback()
+        else:
+            self.once("ready", callback)
+
+    def publish(self, topic, message):
+        # event_key = "event_{}".format(topic.name)
+
+        # TODO: can we avoid the additional cast to dict?
+        application_message = (
+            MqttApplicationMessageBuilder()
+            .WithTopic(topic.name)
+            .WithPayload(json.dumps(dict(message), cls=MessageEncoder))
+            .Build()
+        )
+
+        def _callback(**kwargs):
+            self.client.PublishAsync(application_message, CancellationToken.None)
+            # self.emit(event_key, message)
+
+        self.on_ready(_callback)
+
+    def subscribe(self, topic, callback):
+        event_key = "event_{}".format(topic.name)
+
+        def on_message(event_args):
+            payload = Encoding.UTF8.GetString(event_args.ApplicationMessage.Payload)
+            msg = topic.message_type.parse(json.loads(payload))
+            callback(msg)
+
+        def _subscribe_callback(**kwargs):
+            self.on(event_key, callback)
+
+            subscribe_opts = self.factory.CreateSubscribeOptionsBuilder().WithTopicFilter(lambda f: f.WithTopic(topic.name)).Build()
+            self.client.ApplicationMessageReceivedAsync += on_message
+            self.client.SubscribeAsync(subscribe_opts, self.cancellation_token)
+
+        self.on_ready(_subscribe_callback)
+
+    def advertise(self, topic):
+        advertise_id = "advertise:{}:{}".format(topic.name, self.id_counter)
+        # mqtt does not need anything here
+        return advertise_id
+
+    def unadvertise(self, topic):
+        pass
+
+    def unsubscribe(self, topic):
+        # self.client.unsubscribe(topic.name)
+        pass

compas_eve-0.1.2/src/compas_eve/mqtt/mqtt_paho.py

@@ -0,0 +1,70 @@
+import json
+
+import paho.mqtt.client as mqtt
+
+from ..core import MessageEncoder
+from ..core import Transport
+from ..event_emitter import EventEmitterMixin
+
+
+class MqttTransport(Transport, EventEmitterMixin):
+    def __init__(self, host, port=1883, *args, **kwargs):
+        super(MqttTransport, self).__init__(*args, **kwargs)
+        self.host = host
+        self.port = port
+        self._is_connected = False
+        self.client = mqtt.Client()  # todo: generate client_id
+        self.client.on_connect = self._on_connect
+        self.client.connect(self.host, self.port)
+        self.client.loop_start()
+
+    def close(self):
+        self.client.loop_stop()
+
+    def _on_connect(self, client, userdata, flags, rc):
+        self._is_connected = True
+        self.emit("ready")
+
+    def on_ready(self, callback):
+        if self._is_connected:
+            callback()
+        else:
+            self.once("ready", callback)
+
+    def publish(self, topic, message):
+        # event_key = "event_{}".format(topic.name)
+
+        def _callback(**kwargs):
+            # TODO: can we avoid the additional cast to dict?
+            json_message = json.dumps(dict(message), cls=MessageEncoder)
+            self.client.publish(topic.name, json_message)
+            # self.emit(event_key, message)
+
+        self.on_ready(_callback)
+
+    def subscribe(self, topic, callback):
+        event_key = "event_{}".format(topic.name)
+
+        def _subscribe_callback(**kwargs):
+            self.client.subscribe(topic.name)
+
+            def on_message(client, userdata, msg):
+                msg = topic.message_type.parse(json.loads(msg.payload.decode()))
+                callback(msg)
+
+            self.client.on_message = on_message
+
+            self.on(event_key, callback)
+
+        self.on_ready(_subscribe_callback)
+
+    def advertise(self, topic):
+        advertise_id = "advertise:{}:{}".format(topic.name, self.id_counter)
+        # mqtt does not need anything here
+        return advertise_id
+
+    def unadvertise(self, topic):
+        pass
+
+    def unsubscribe(self, topic):
+        self.client.unsubscribe(topic.name)

compas_eve-0.1.2/src/compas_eve/rhino/install.py

@@ -0,0 +1,11 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import compas
+import compas.plugins
+
+
+@compas.plugins.plugin(category="install")
+def installable_rhino_packages():
+    return ["compas_eve"]

compas_eve-0.1.2/src/compas_eve.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.1
+Name: compas-eve
+Version: 0.1.2
+Summary: COMPAS Event Extensions: adds event-based communication infrastructure to the COMPAS framework.
+Home-page: https://github.com/compas-dev/compas_eve
+Author: Gonzalo Casas
+Author-email: casas@arch.ethz.ch
+License: MIT license
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.md
+
+# compas_eve
+
+COMPAS Event Extensions: adds event-based communication infrastructure to the COMPAS framework.
+
+
+## Getting started with this project
+
+### Setup code editor
+
+1. Open project folder in VS Code
+2. Select python environment for the project
+3. First time using VS Code and on Windows? Make sure select the correct terminal profile: `Ctrl+Shift+P`, `Terminal: Select Default Profile` and select `Command Prompt`.
+
+> All terminal commands in the following sections can be run from the VS Code integrated terminal. 
+
+
+### First steps with git
+
+1. Go to the `Source control` tab
+2. Make an initial commit with all newly created files
+
+
+### First steps with code
+
+1. Install the newly created project 
+
+        pip install -e .
+
+2. Install it on Rhino
+
+        python -m compas_rhino.install
+
+
+### Code conventions
+
+Code convention follows [PEP8](https://pep8.org/) style guidelines and line length of 120 characters.
+
+1. Check adherence to style guidelines
+
+        invoke lint
+
+2. Format code automatically
+
+        invoke format
+
+
+### Documentation
+
+Documentation is generated automatically out of docstrings and [RST](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html) files in this repository
+
+1. Generate the docs
+
+        invoke docs
+
+2. Check links in docs are valid
+
+        invoke linkcheck
+
+3. Open docs in your browser (file explorer -> `dist/docs/index.html`)
+
+
+### Testing
+
+Tests are written using the [pytest](https://docs.pytest.org/) framework
+
+1. Run all tests from terminal
+
+        invoke test
+
+2. Or run them from VS Code from the `Testing` tab
+
+
+### Developing Grasshopper components
+
+We use [Grasshopper Componentizer](https://github.com/compas-dev/compas-actions.ghpython_components) to develop Python components that can be stored and edited on git.
+
+1. Build components
+
+        invoke build-ghuser-components
+
+2. Install components on Rhino
+
+        python -m compas_rhino.install
+
+
+### Publish release
+
+Releases follow the [semver](https://semver.org/spec/v2.0.0.html) versioning convention.
+
+1. Create a new release
+
+        invoke release major

compas_eve-0.1.2/src/compas_eve.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+AUTHORS.md
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.cfg
+setup.py
+src/compas_eve/__init__.py
+src/compas_eve/__main__.py
+src/compas_eve/core.py
+src/compas_eve/event_emitter.py
+src/compas_eve.egg-info/PKG-INFO
+src/compas_eve.egg-info/SOURCES.txt
+src/compas_eve.egg-info/dependency_links.txt
+src/compas_eve.egg-info/not-zip-safe
+src/compas_eve.egg-info/requires.txt
+src/compas_eve.egg-info/top_level.txt
+src/compas_eve/memory/__init__.py
+src/compas_eve/mqtt/__init__.py
+src/compas_eve/mqtt/mqtt_cli.py
+src/compas_eve/mqtt/mqtt_paho.py
+src/compas_eve/mqtt/netlib/MQTTnet.dll
+src/compas_eve/rhino/__init__.py
+src/compas_eve/rhino/install.py

compas_eve-0.1.2/src/compas_eve.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

compas_eve-0.1.2/src/compas_eve.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

compas_eve-0.1.2/src/compas_eve.egg-info/requires.txt

@@ -0,0 +1,2 @@
+compas
+paho-mqtt

compas_eve-0.1.2/src/compas_eve.egg-info/top_level.txt

@@ -0,0 +1 @@
+compas_eve