tangods-mcmax 1.0.3__tar.gz

tangods_mcmax-1.0.3/.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

tangods_mcmax-1.0.3/.gitlab-ci.yml

@@ -0,0 +1,58 @@
+stages:
+  - pre-commit
+  - build
+  - test
+  - deploy
+
+precommit-job:
+  image: python:3.11-bookworm
+  stage: pre-commit
+  before_script:
+    - python -m venv ci-venv
+    - source ci-venv/bin/activate
+    - pip install --upgrade pip
+    - pip install pre-commit
+  script:
+    - pre-commit run --all
+
+build-job:
+  image: python:3.11-bookworm
+  stage: build
+  before_script:
+    - apt update
+    - apt install -y cppzmq-dev libboost-dev libboost-python-dev libtango-dev libomniorb4-dev
+    - python -m venv ci-venv
+    - source ci-venv/bin/activate
+    - pip install --upgrade pip
+  script:
+    - pip install build wheel setuptools_scm
+    - python -m build
+  artifacts:
+    paths:
+      - dist/
+
+unit-test-job:
+  image: python:3.11-bookworm
+  stage: test
+  before_script:
+    - apt update
+    - apt install -y cppzmq-dev libboost-dev libboost-python-dev libtango-dev libomniorb4-dev
+    - python -m venv ci-venv
+    - source ci-venv/bin/activate
+    - pip install --upgrade pip
+  script:
+    - pip install '.[test]'
+    - pytest -v
+
+deploy:
+  image: python:3.11-bookworm
+  stage: deploy
+  only:
+    - tags
+  before_script:
+    - python -m venv ci-venv
+    - source ci-venv/bin/activate
+    - pip install --upgrade pip
+    - pip install twine
+  script:
+    - twine upload dist/* -u __token__ -p $PYPI_API_TOKEN

tangods_mcmax-1.0.3/.pre-commit-config.yaml

@@ -0,0 +1,24 @@
+---
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: check-json
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+      - id: mixed-line-ending
+      - id: fix-byte-order-marker
+      - id: check-executables-have-shebangs
+      - id: check-merge-conflict
+      - id: check-symlinks
+  - repo: https://github.com/pycqa/flake8
+    rev: 7.1.1
+    hooks:
+      - id: flake8
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black
+        language_version: python3
+        args: [-l 79]

tangods_mcmax-1.0.3/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  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 that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU 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 as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

tangods_mcmax-1.0.3/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.2
+Name: tangods-mcmax
+Version: 1.0.3
+Summary: A tango device server to control the microcontrollers in the project MC-MAX
+Author-email: Antonio Bartalesi <antonio.bartalesi@gmail.com>, Laura Torres Garcia <lautg88@gmail.com>
+Project-URL: repository, https://gitlab.com/ABartalesi/mc-max-tango-device-server
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytango>=9.5
+Requires-Dist: paho-mqtt>=2.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# Tango Device Server for the MC-MAX project
+
+This tango device server connects to an mqtt broker using the paho-mqtt library
+and upon success reads the esp-32 self description topic, and starts a tango
+device with dynamic attributes and commands.
+
+## Properties
+
+Name | Description
+---- | ----
+`broker` | A string, URI of the mqtt broker
+`username` | The username for the mqtt broker connection
+`password` | The password for the mqtt broker connection
+`mqtt_name` | The name of the microcontroller in the mqtt topic tree. Usually it's the hostname of the microcontroller (without domain).

tangods_mcmax-1.0.3/README.md

@@ -0,0 +1,14 @@
+# Tango Device Server for the MC-MAX project
+
+This tango device server connects to an mqtt broker using the paho-mqtt library
+and upon success reads the esp-32 self description topic, and starts a tango
+device with dynamic attributes and commands.
+
+## Properties
+
+Name | Description
+---- | ----
+`broker` | A string, URI of the mqtt broker
+`username` | The username for the mqtt broker connection
+`password` | The password for the mqtt broker connection
+`mqtt_name` | The name of the microcontroller in the mqtt topic tree. Usually it's the hostname of the microcontroller (without domain).

tangods_mcmax-1.0.3/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+
+requires = ["setuptools", "setuptools_scm", "build"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+write_to = "src/mcmax/_version.py"
+
+[project]
+dynamic = ["version"]
+name = "tangods-mcmax"
+dependencies = [
+  "pytango>=9.5",
+  "paho-mqtt>=2.0",
+]
+authors = [
+  {name = "Antonio Bartalesi", email = "antonio.bartalesi@gmail.com"},
+  {name = "Laura Torres Garcia", email = "lautg88@gmail.com"},
+]
+description = "A tango device server to control the microcontrollers in the project MC-MAX"
+readme = "README.md"
+classifiers = [
+"License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+]
+
+[project.urls]
+repository = "https://gitlab.com/ABartalesi/mc-max-tango-device-server"
+
+[project.scripts]
+McMaxTangoDs = "mcmax:main"

tangods_mcmax-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tangods_mcmax-1.0.3/specs/README.md

@@ -0,0 +1,73 @@
+# Specifications for the MC-MAX project
+
+The MC-MAX project encompasses four components:
+
+1. Microcontroller firmware
+2. Tango device server
+3. A data formatting specification to allow the two system above to communicate, described [further down](#mqtt-data-exchange-format) in this document.
+4. CI/CD toolchain (gitlab CI + ansible) to monitor the firmware and deploy updates.
+
+## Microcontroller firmware
+
+The microcontroller must belong to Espressif's ESP32 family.
+
+The firmware must be compiled using the [esp-idf](https://github.com/espressif/esp-idf) toolchain. This is because it simplify devOps.
+
+The Microcontroller must have the following features:
+1. Use OTA firmware update: it should be possible to update the microcontroller remotely.
+2. Use MQTT protocol: simple and easy, the microcontroller should describe its own features and firmware.
+3. Self describe its features according to the [MQTT data exchange specification](#mqtt-data-exchange-format).
+4. [*Not confirmed*] display a web page for configuration. In any case, the MQTT broker address must be configured somehow.
+
+## Tango DS
+
+There should be only **one** tango device server class, capable of adapting to all the different firmwares.
+
+One tango device connects to one microcontroller.
+
+It must have a tango property for the microcontroller hostname, to find the appropriate device in the MQTT tree.
+
+It must populate attributes and commands dynamically, by reading the microcontroller self description through MQTT.
+
+## MQTT data exchange specification
+
+The microcontroller must advertise the following:
+1. Firmware flavor (a name, example "Relay controller").
+2. Firmware version. Must be the same as the output of `git-describe`.
+3. Self description. A JSON formatted dictionary having all the tango goodies: which tango attributes, which tango commands and so on.
+4. Somewhere to publish the data.
+5. Somewhere to listen for data.
+
+Here is how the MQTT topic tree should look like:
+
+```
+mc_max
+└─ <hostname, without domain>
+   ├─ firmware_name: str
+   ├─ firmware_version: str
+   ├─ tango_attributes: str (list of valid keyword dictionaries to create attributes, JSON formatted)
+   ├─ tango_commands: str (list of valid keyword dictionaries to create commands, JSON formatted)
+   ├─ mc_output
+   │  ├─ variable_1: str
+   │  ├─ variable_2: str
+   │  ├─ ...
+   │  └─ variable_n: str
+   ├─ mc_input
+   │  ├─ variable_1: str
+   │  ├─ variable_2: str
+   │  ├─ ...
+   │  └─ variable_n: str
+   └─ command
+      ├─ command_1: str
+      ├─ command_2: str
+      ├─ ...
+      └─ command_n: str
+```
+
+So to have a complete example:
+
+`mc_max/mydevice/mc_output/voltage` could contain useful data that must be translated to a tango attribute; while `mc_max/mydevice/mc_input/voltage` could be used as a setpoint for a controlled process variable.
+
+For a command, there is a list called `command`. Commands always have a string as `dtype_in`. Exaple writing `"1"` into `mc_max/mydevice/command/enable_voltage` could tell the microcontroller to perform a specific action such as switching voltage on.
+
+This feature could be used with more complex parameters, to pass data together with a command. Example: writing `'{"time": "1s", "voltage": "2V"}'` into the topic `mc_max/mydevice/command/pulse_voltage` could perform the complex action of pulsing the voltage on the microcontroller.

tangods_mcmax-1.0.3/src/mcmax/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["main", "McMaxTangoDs", "MqttMessage"]
+
+from .mcmax import main, McMaxTangoDs, MqttMessage

tangods_mcmax-1.0.3/src/mcmax/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '1.0.3'
+__version_tuple__ = version_tuple = (1, 0, 3)

tangods_mcmax-1.0.3/src/mcmax/mcmax.py

@@ -0,0 +1,316 @@
+import json
+from tango.server import (
+    AttrDataFormat,
+    Device,
+    attribute,
+    command,
+    device_property,
+)
+from tango import AttrQuality, AttrWriteType, DevState, DispLevel
+from tango import GreenMode
+from paho.mqtt.client import Client
+from paho.mqtt.enums import CallbackAPIVersion, MQTTProtocolVersion
+from datetime import datetime
+from time import time
+from dataclasses import dataclass
+import builtins
+import types
+
+
+@dataclass
+class MqttMessage:
+    """MQTT message"""
+
+    payload: str
+    topic: str
+
+
+class McMaxTangoDs(Device):
+    """Tango device server to control MC-MAX microcontrollers thru MQTT"""
+
+    green_mode = GreenMode.Asyncio
+
+    # To connect to the MQTT server
+    broker = device_property(dtype=str, default_value="localhost")
+    username = device_property(dtype=str, default_value="")
+    password = device_property(dtype=str, default_value="")
+    mqtt_name = device_property(dtype=str, default_value="")
+
+    firmware_name = attribute(dtype=str, display_level=DispLevel.EXPERT)
+    firmware_version = attribute(dtype=str, display_level=DispLevel.EXPERT)
+
+    async def init_device(self):
+        self.mc_attributes_description = []
+        self.rec_messages: list[MqttMessage] = []
+        self.old_attributes = []
+        self.old_commands = []
+        self.max_msg_circular_buffer = 10
+        self.last_received_values = {}
+        self.conversions = {}
+        self._firmware_name = ""
+        self._firmware_version = ""
+
+        await super().init_device()
+        self.info_stream("Connecting to MQTT server")
+        self.set_state(DevState.INIT)
+        self.set_status(
+            f"Initialization started {datetime.now()}.\nTrying to connect."
+        )
+
+        # Creating a client instance
+        self.mqtt = Client(
+            callback_api_version=CallbackAPIVersion.VERSION2,
+            protocol=MQTTProtocolVersion.MQTTv5,
+        )
+        try:
+            self.connect()
+        except Exception as exc:
+            msg = f"Error connecting to the MQTT server: {exc}"
+            self.error_stream(msg)
+            self.set_state(DevState.FAULT)
+            self.set_status(msg)
+            return
+
+        # Subscribe to firmware name
+        topic = f"mc_max/{self.mqtt_name}/firmware_name"
+        self.mqtt.subscribe(topic=topic)
+        self.mqtt.message_callback_add(
+            sub=topic, callback=self.process_firmware_name
+        )
+
+        # Subscribe to firmware version
+        topic = f"mc_max/{self.mqtt_name}/firmware_version"
+        self.mqtt.subscribe(topic=topic)
+        self.mqtt.message_callback_add(
+            sub=topic, callback=self.process_firmware_version
+        )
+
+        topic = f"mc_max/{self.mqtt_name}/tango_attributes"
+        self.mqtt.subscribe(topic=topic)
+        self.mqtt.message_callback_add(
+            sub=topic, callback=self.process_attributes_self_description
+        )
+
+        topic = f"mc_max/{self.mqtt_name}/tango_commands"
+        self.mqtt.subscribe(topic=topic)
+        self.mqtt.message_callback_add(
+            sub=topic, callback=self.process_commands_self_description
+        )
+
+        # TODO mc should be able to publish tango state
+        self.set_status(
+            f"Initialization completed {datetime.now()}.\n"
+            "Waiting for Microcontroller self description..."
+        )
+
+    # MQTT connection
+    def connect(self):
+        self.mqtt.username_pw_set(
+            username=self.username, password=self.password
+        )
+        self.mqtt.connect(host=self.broker)
+        self.mqtt.loop_start()
+
+    def process_firmware_name(self, client, userdata, msg):
+        self._firmware_name = msg.payload
+
+    def process_firmware_version(self, client, userdata, msg):
+        self._firmware_version = msg.payload
+
+    def process_attributes_self_description(self, client, userdata, msg):
+        # load as JSON
+        try:
+            self.mc_attributes_description = json.loads(msg.payload)
+        except Exception as exc:
+            msg = (
+                "Error in microcontroller self description: "
+                f"Exception was: {exc}"
+            )
+            self.error_stream(msg)
+            raise RuntimeError(msg)
+
+        # Clean up old attributes
+        for old_attribute in self.old_attributes:
+            try:
+                self.remove_attribute(old_attribute)
+            except Exception:
+                self.warn_stream(
+                    f"Tried to remove attribute {attribute} "
+                    "without success, ignoring."
+                )
+        self.old_attributes = []
+
+        # Process the list of attribute dictionaries
+        for new_attribute in self.mc_attributes_description:
+            if "access" in new_attribute:
+                new_attribute["access"] = getattr(
+                    AttrWriteType, new_attribute["access"]
+                )
+            if "display_level" in new_attribute:
+                new_attribute["display_level"] = getattr(
+                    DispLevel, new_attribute["display_level"]
+                )
+            if "dformat" in new_attribute:
+                new_attribute["dformat"] = getattr(
+                    AttrDataFormat, new_attribute["dformat"]
+                )
+            attr = attribute(**new_attribute)
+            if attr.attr_write in [
+                AttrWriteType.READ_WRITE,
+                AttrWriteType.WRITE,
+                AttrWriteType.READ_WITH_WRITE,
+            ]:
+                write_method = self.generic_write
+            else:
+                write_method = None
+            self.add_attribute(
+                attr, r_meth=self.generic_read, w_meth=write_method
+            )
+
+            self.old_attributes.append(attr.name)
+            try:
+                _dtype = new_attribute["dtype"]
+                if _dtype == "bool":
+                    self.conversions[attr.name] = self.str2bool
+                else:
+                    self.conversions[attr.name] = getattr(builtins, _dtype)
+            except KeyError:
+                msg = (
+                    "Error in microcontroller self description: no dtype "
+                    f"specified for attribute {attr.name}"
+                )
+                self.error_stream(msg)
+                raise RuntimeError(msg)
+
+            self.set_change_event(attr.name, True)
+            mc_output_data_topic = (
+                f"mc_max/{self.mqtt_name}/mc_output/{attr.name}"
+            )
+            self.mqtt.subscribe(topic=mc_output_data_topic)
+            self.debug_stream(f"Subscribing to {mc_output_data_topic}")
+
+            def generic_event_pusher(client, userdata, msg):
+                # get attribute name
+                att_name = msg.topic.split("/")[-1]
+                try:
+                    conversion_function = self.conversions[att_name]
+                    value = conversion_function(msg.payload.decode("utf-8"))
+                    quality = AttrQuality.ATTR_VALID
+                    self.last_received_values[att_name] = value
+                    self.debug_stream(f"{att_name} = {value}")
+                except AttributeError:
+                    # The dtype is not a builtin
+                    self.last_received_values[att_name] = None
+                    msg = (
+                        "Error in microcontroller self description: dtype "
+                        f"{self.conversions[att_name]} for attribute "
+                        f"{att_name} does not match any python "
+                        "builtin data type"
+                    )
+                    self.error_stream(msg)
+                    # In this case, we interrupt the code flow
+                    # because we don't even know what dtype we should push
+                    raise RuntimeError(msg)
+                except Exception as exc:
+                    self.last_received_values[att_name] = None
+                    # trick to have a placeholder value of correct type
+                    # Must be set to ATTR_INVALID
+                    value = conversion_function()
+                    quality = AttrQuality.ATTR_INVALID
+                    self.error_stream(
+                        f"Could not translate value {value} for attribute "
+                        f"{att_name}, exception was {exc}"
+                    )
+                self.push_change_event(att_name, value, time(), quality)
+
+            # give this function a unique name and make it an attribute
+            specific_callback_name = f"{attr.name}_event_pusher"
+            setattr(self, specific_callback_name, generic_event_pusher)
+            self.mqtt.message_callback_add(
+                sub=mc_output_data_topic,
+                callback=getattr(self, specific_callback_name),
+            )
+        if self.dev_state() is DevState.INIT:
+            # here if first self description received since init
+            self.set_state(DevState.ON)
+            self.set_status(
+                f"Microcontroller description received {datetime.now()}.\n"
+                "Device operating normally."
+            )
+
+    def _create_method(self, name):
+        @command(dtype_in=str)
+        async def dynamic_method(self, parameters):
+            topic = f"mc_max/{self.mqtt_name}/command/{name}"
+            payload = parameters
+            self.mqtt.publish(topic=topic, payload=payload)
+
+        dynamic_method.__name__ = name
+
+        return dynamic_method
+
+    def process_commands_self_description(self, client, userdata, msg):
+        # load as JSON
+        try:
+            self.mc_commands_description = json.loads(msg.payload)
+        except Exception as exc:
+            msg = (
+                "Error in microcontroller commands self description: "
+                f"Exception was: {exc}"
+            )
+            self.error_stream(msg)
+            raise RuntimeError(msg)
+
+        # Clean up old commands
+        for old_command in self.old_commands:
+            try:
+                self.remove_command(old_command)
+            except Exception:
+                self.warn_stream(
+                    f"Failed to remove command {old_command}. " "Ignoring it"
+                )
+        self.old_commands = []
+
+        # Process the list of attribute dictionaries
+        for new_command in self.mc_commands_description:
+            setattr(
+                self,
+                new_command["name"],
+                types.MethodType(
+                    self._create_method(new_command["name"]), self
+                ),
+            )
+            self.add_command(getattr(self, new_command["name"]))
+            self.old_commands.append(new_command["name"])
+
+    async def generic_read(self, attr):
+        self.debug_stream(f"Generic read for attribute {attr.get_name()}")
+        if attr.get_name() not in self.last_received_values:
+            attr.set_quality(AttrQuality.ATTR_INVALID)
+            return
+        return self.last_received_values[attr.get_name()]
+
+    async def generic_write(self, attr):
+        topic = f"mc_max/{self.mqtt_name}/mc_input/{attr.get_name()}"
+        payload = str(attr.get_write_value())
+        self.mqtt.publish(topic=topic, payload=payload)
+
+    async def read_firmware_version(self):
+        return self._firmware_version
+
+    async def read_firmware_name(self):
+        return self._firmware_name
+
+    def str2bool(self, data: str) -> bool:
+        if data.lower() in ("true", "yes", "on", "1"):
+            return True
+        else:
+            return False
+
+
+def main():
+    McMaxTangoDs.run_server()
+
+
+if __name__ == "__main__":
+    main()

tangods_mcmax-1.0.3/src/tangods_mcmax.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.2
+Name: tangods-mcmax
+Version: 1.0.3
+Summary: A tango device server to control the microcontrollers in the project MC-MAX
+Author-email: Antonio Bartalesi <antonio.bartalesi@gmail.com>, Laura Torres Garcia <lautg88@gmail.com>
+Project-URL: repository, https://gitlab.com/ABartalesi/mc-max-tango-device-server
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytango>=9.5
+Requires-Dist: paho-mqtt>=2.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# Tango Device Server for the MC-MAX project
+
+This tango device server connects to an mqtt broker using the paho-mqtt library
+and upon success reads the esp-32 self description topic, and starts a tango
+device with dynamic attributes and commands.
+
+## Properties
+
+Name | Description
+---- | ----
+`broker` | A string, URI of the mqtt broker
+`username` | The username for the mqtt broker connection
+`password` | The password for the mqtt broker connection
+`mqtt_name` | The name of the microcontroller in the mqtt topic tree. Usually it's the hostname of the microcontroller (without domain).

tangods_mcmax-1.0.3/src/tangods_mcmax.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+.gitignore
+.gitlab-ci.yml
+.pre-commit-config.yaml
+LICENSE
+README.md
+pyproject.toml
+specs/README.md
+src/mcmax/__init__.py
+src/mcmax/_version.py
+src/mcmax/mcmax.py
+src/tangods_mcmax.egg-info/PKG-INFO
+src/tangods_mcmax.egg-info/SOURCES.txt
+src/tangods_mcmax.egg-info/dependency_links.txt
+src/tangods_mcmax.egg-info/entry_points.txt
+src/tangods_mcmax.egg-info/requires.txt
+src/tangods_mcmax.egg-info/top_level.txt
+tests/test_mcmax.py

tangods_mcmax-1.0.3/src/tangods_mcmax.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tangods_mcmax-1.0.3/src/tangods_mcmax.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+McMaxTangoDs = mcmax:main

tangods_mcmax-1.0.3/src/tangods_mcmax.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pytango>=9.5
+paho-mqtt>=2.0
+
+[test]
+pytest

tangods_mcmax-1.0.3/src/tangods_mcmax.egg-info/top_level.txt

@@ -0,0 +1 @@
+mcmax

tangods_mcmax-1.0.3/tests/test_mcmax.py

@@ -0,0 +1,206 @@
+import pytest
+import json
+from tango import DevState
+from tango.server import command
+from tango.test_context import DeviceTestContext
+from unittest.mock import patch
+
+# Import tango DS
+from mcmax import McMaxTangoDs, MqttMessage
+
+
+MQTT_NAME = "test"
+
+
+@pytest.fixture
+def deviceProxy():
+    device = DeviceTestContext(
+        McMaxTangoDs,
+        properties={
+            "broker": "localhost",
+            "username": "user",
+            "password": "password",
+            "mqtt_name": MQTT_NAME,
+        },
+        process=True,
+    )
+    yield device
+
+
+def testImport():
+    """Test importation of the Tango DS"""
+    from mcmax import McMaxTangoDs  # noqa: F401
+
+
+@patch("mcmax.mcmax.Client")
+def testInit(mocker, deviceProxy):
+    """Test device goes into INIT when initialised"""
+    with deviceProxy as proxy:
+        assert proxy.status().startswith("Initialization completed")
+        assert proxy.state() == DevState.INIT
+
+
+@patch(
+    "mcmax.mcmax.Client.username_pw_set",
+    side_effect=ValueError("PROBLEM"),
+)
+def testConnectionFailed(mocker, deviceProxy):
+    """Test device failed to connect to the MQTT broker"""
+    with deviceProxy as proxy:
+        assert proxy.state() == DevState.FAULT
+        assert proxy.status() == "Error connecting to the MQTT server: PROBLEM"
+
+
+def testProcessingFirmware():
+    """Test device can process firmware information"""
+
+    # Process the messages
+    McMaxTangoDs.process_firmware_name(
+        McMaxTangoDs,
+        None,
+        None,
+        MqttMessage(
+            topic=f"mc_max/{MQTT_NAME}/firmware_name", payload="TestFirmware"
+        ),
+    )
+    McMaxTangoDs.process_firmware_version(
+        McMaxTangoDs,
+        None,
+        None,
+        MqttMessage(
+            topic=f"mc_max/{MQTT_NAME}/firmware_version", payload="1.0.0"
+        ),
+    )
+
+    # Assert values
+    assert McMaxTangoDs._firmware_name == "TestFirmware"
+    assert McMaxTangoDs._firmware_version == "1.0.0"
+
+
+def testProcessingAttributesSelfDescription():
+    """Test device can receive attribute self-description information"""
+
+    class MqttMessageRaw:
+        topic = ""
+        payload = None
+
+        def __init__(self, topic, payload):
+            self.topic = topic
+            self.payload = payload
+
+    class TestDev(McMaxTangoDs):
+        @command(dtype_in=str)
+        async def test_process_attribute_self_description(self, string):
+            msg = MqttMessage(payload=string, topic="test/notopic")
+            self.process_attributes_self_description(None, None, msg)
+
+        @command(dtype_in=float)
+        async def test_add_fake_voltage_value(self, value):
+            msg = MqttMessageRaw(
+                topic=f"mc_max/{MQTT_NAME}/mc_output/voltage",
+                payload=str(value).encode("ascii"),
+            )
+            self.voltage_event_pusher(None, None, msg)
+
+    with DeviceTestContext(
+        TestDev,
+        properties={
+            "broker": "localhost",
+            "username": "user",
+            "password": "password",
+            "mqtt_name": MQTT_NAME,
+        },
+        process=True,
+    ) as device:
+
+        attributes_description = [
+            {
+                "name": "voltage",
+                "dtype": "float",
+                "Unit": "V",
+                "fget": "default_get",
+            }
+        ]
+        attributes_description = json.dumps(attributes_description)
+
+        # Process the messages
+        device.test_process_attribute_self_description(attributes_description)
+
+        assert "voltage" in device.get_attribute_list()
+
+        device.test_add_fake_voltage_value(123.4)
+
+        assert device.voltage == 123.4
+
+        attributes_description_2 = [
+            {
+                "name": "voltage_2",
+                "dtype": "float",
+                "Unit": "V",
+                "fget": "default_get",
+            }
+        ]
+        attributes_description_2 = json.dumps(attributes_description_2)
+
+        # Process the messages
+        device.test_process_attribute_self_description(
+            attributes_description_2
+        )
+
+        assert "voltage" not in device.get_attribute_list()
+
+        assert "voltage_2" in device.get_attribute_list()
+
+
+@patch("mcmax.mcmax.Client")
+def testDynamicCommandCreation(mocker, deviceProxy):
+    """Test device can send messages to MQTT broker"""
+
+    class TestDev(McMaxTangoDs):
+        @command(dtype_in=str)
+        async def test_process_commands_self_description(self, string):
+            msg = MqttMessage(payload=string, topic="test/notopic")
+            self.process_commands_self_description(None, None, msg)
+
+    with DeviceTestContext(
+        TestDev,
+        properties={
+            "broker": "localhost",
+            "username": "user",
+            "password": "password",
+            "mqtt_name": MQTT_NAME,
+        },
+        process=True,
+    ) as device:
+
+        commands_description = [
+            {
+                "name": "new_command",
+            }
+        ]
+        commands_description = json.dumps(commands_description)
+
+        # Process the messages
+        device.test_process_commands_self_description(commands_description)
+
+        assert "new_command" in device.get_command_list()
+
+        device.new_command("test string input")
+
+        device.test_process_commands_self_description(commands_description)
+
+        commands_description_2 = [
+            {
+                "name": "new_command_2",
+            }
+        ]
+        commands_description_2 = json.dumps(commands_description_2)
+
+        # Process the second mesage
+        device.test_process_commands_self_description(commands_description_2)
+
+        assert "new_command" not in device.get_command_list()
+
+        assert "new_command_2" in device.get_command_list()
+
+        device.new_command_2("test string input")