stinger-ipc 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

stingeripc/templates/markdown/index.md.jinja2

@@ -0,0 +1,142 @@
+# _{{stinger.name}}_ API Overview 
+
+{{stinger.description}}
+{%macro argrow(arg) -%}
+|{{arg.name|center(15)}}|
+{%-if arg.arg_type.name.lower() == "enum" or arg.arg_type.name.lower() == "struct"%}{{arg.markdown_type|center(10)}}
+{%-else%}{{arg.json_type|center(10)}}
+{%-endif%}{%if arg.optional%} (optional){%endif%}|
+{{- arg.description or ''}}|
+{%- endmacro %}
+{%macro argtable(arglist) -%}
+| Name          | Type     |Description|
+|---------------|----------|-----------|
+{%-for arg in arglist%}
+{{argrow(arg)}}
+{%- endfor %}
+{%- endmacro %}
+{%if stinger.signals | length > 0 %}
+## Signals
+
+Signals are messages from the server to clients.
+
+```plantuml
+@startuml
+Client <<- Server : Signal(Parameters)
+@enduml
+```
+{%for sig_name, signal in stinger.signals.items()%}
+### Signal `{{sig_name}}`
+
+{{signal.documentation or "_No documentation for this signal_"}}
+
+#### Signal Parameters for `{{sig_name}}`
+
+{{argtable(signal.arg_list)}}
+
+#### Code Examples
+
+<details>
+  <summary>Python Client</summary>
+
+```python
+@client.receive_{{sig_name | snake_case }}
+def on_{{sig_name | snake_case }}({%for arg in signal.arg_list%}{{arg.name}}: {{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}):
+    print(f"Got a '{{sig_name}}' signal: {%for arg in signal.arg_list%}{{arg.name}}={ {{arg.name}} } {%endfor%}")
+```
+
+</details>
+
+<details>
+  <summary>Rust Server</summary>
+
+```rust
+server.emit_{{sig_name|snake_case}}({%for arg in signal.arg_list%}{{arg.get_random_example_value(lang="rust")}}{%if not loop.last%}, {%endif%}{%endfor%}).await;
+```
+
+</details>
+
+{%endfor%}{#- end for each signal -#}
+{%endif%}{#- end if there are signals -#}
+
+{#- ------------------------------------------------------- -#}
+{%if stinger.methods | length > 0 %}
+## Methods
+
+Methods are requests from a client to a server and the server provides a response back to the client:
+
+```plantuml
+@startuml
+Client ->> Server : Request(Parameters)
+Client <<-- Server: Response(Parameters)
+@enduml
+```
+
+{%for method_name, method in stinger.methods.items()%}
+### Method `{{method_name}}`
+
+{{method.documentation or "_No documentation for this method_"}}
+
+#### Request Parameters
+{%if method.arg_list | length == 0%}
+There are no arguments for this request.
+{%else-%}
+{{argtable(method.arg_list)}}
+{%endif%}{# number of args #}
+#### Return Parameters
+
+{%if method.return_value_type == "struct" %}
+{{argtable(method.return_value)}}
+{%elif method.return_value_type is false -%}
+There is no return value for this method call.
+{%else-%}
+The return value type is `{{method.return_value.json_type}}`.
+{%endif-%}
+{%endfor-%}
+{%endif%}
+{#- ------------------------------------------------------- #}
+{%if stinger.properties | length > 0 %}## Properties
+
+Properties are values (or a set of values) held by the server.   They are re-published when the value changes. 
+
+```plantuml
+@startuml
+Server -> Server : Set Property
+Client <<- Server: Property Updated
+@enduml
+```
+{%for prop_name, prop in stinger.properties.items()%}
+### Property `{{prop_name}}`
+
+{{prop.documentation or "_No documentation is available for this property_"}}{%if prop.read_only %}
+
+This property is **read-only**.  It can only be modified by the server.{%endif%}
+
+{{argtable(prop.arg_list)}}
+{%endfor%}{# for each property #}
+{%endif%}{#end condition that there are a number of properties#}
+{%if stinger.enums | length > 0%}## Enums
+{%endif%}
+{%for ie_name, ie in stinger.enums.items() %}
+{#- ------------------------------------------------------- -#}
+### Enum `{{ie.class_name }}`
+
+<a name="Enum-{{ie.class_name}}"></a>{{ie.description or "_No description exists for this enumeration._"}}
+
+{%for value in ie.values -%}
+* {{value}} ({{loop.index}}) 
+{%- if ie.value_descriptions and ie.value_descriptions|length >= loop.index %}
+  - {{ie.value_descriptions[loop.index0]}}{% endif %}
+{%endfor%}
+{%endfor%}
+{#- ------------------------------------------------------- #}
+## Structures
+
+Structures are a group of values and may be used as an argument in signals, methods, or properties.  Defining a structure allows for easy reuse.
+{%for istruct_name, istruct in stinger.structs.items() %}
+### Struct `{{istruct.class_name }}`
+
+<a name="Struct-{{istruct.class_name}}"></a>{{istruct.description or "_No general description exists for this structure_"}}
+
+{{argtable(istruct.members)}}
+{%endfor%}

stingeripc/templates/python/__init__.py.jinja2

@@ -0,0 +1 @@
+# Nothing to see here.

stingeripc/templates/python/client.py.jinja2

@@ -0,0 +1,309 @@
+"""
+DO NOT MODIFY THIS FILE. {# Unless you see this, which means you are editing the template. #} It is automatically generated and changes will be over-written
+on the next generation.
+
+This is the Client for the {{stinger.name}} interface.
+"""
+
+from typing import Dict, Callable, List, Any
+from uuid import uuid4
+from functools import partial
+import json
+import logging
+{%if stinger.methods | length > 0 %}
+import asyncio
+import concurrent.futures as futures
+from method_codes import *
+{%endif%}
+from connection import BrokerConnection
+{%if stinger.uses_enums()%}import {{stinger.get_enum_module_name()}} as {{stinger.get_enum_module_alias()}}{%endif%}
+
+logging.basicConfig(level=logging.DEBUG)
+
+{%for sig_name, sig in stinger.signals.items()-%}
+{{sig_name | UpperCamelCase}}SignalCallbackType = Callable[[{%for arg in sig.arg_list%}{{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}], None]
+{%endfor%}
+{%-for method_name, method in stinger.methods.items()-%}
+{{method_name | UpperCamelCase}}MethodResponseCallbackType = Callable[[{%if method.return_value%}{{method.return_value.python_type}}{%endif%}], None]
+{%endfor%}
+{%for prop_name, prop in stinger.properties.items()-%}
+{{prop_name | UpperCamelCase}}PropertyUpdatedCallbackType = Callable[[{{prop.python_class}}], None]
+{%endfor%}
+
+class {{stinger.python.client_class_name}}:
+
+    def __init__(self, connection: BrokerConnection):
+        """ Constructor for a `{{stinger.python.client_class_name}}` object.
+        """
+        self._logger = logging.getLogger('{{stinger.python.client_class_name}}')
+        self._logger.setLevel(logging.DEBUG)
+        self._logger.debug("Initializing {{stinger.python.client_class_name}}")
+        self._client_id = str(uuid4())
+        self._conn = connection
+        self._conn.set_message_callback(self._receive_message)
+        {%if stinger.methods | length > 0 %}
+        self._pending_method_responses: dict[str, Callable[..., None]] = {}
+        {%endif%}
+        {%for prop_name, prop_spec in stinger.properties.items()-%}
+        self._property_{{prop_name}}: {{prop_spec.python_class}}|None = None
+        self._{{prop_name}}_prop_subscription_id: int = self._conn.subscribe("{{prop_spec.value_topic}}")
+        self._changed_value_callbacks_for_{{prop_name}}: list[{{prop_name | UpperCamelCase}}PropertyUpdatedCallbackType] = []
+        {%endfor-%}
+        {%-for sig_name in stinger.signals.keys()-%}
+        self._signal_recv_callbacks_for_{{sig_name | snake_case }}: list[{{sig_name | UpperCamelCase}}SignalCallbackType] = []
+        {%endfor-%}
+        {%-for method_name, method in stinger.methods.items()-%}
+        self._{{method_name}}_method_call_subscription_id: int = self._conn.subscribe(f"{{method.response_topic('{self._client_id}')}}")
+        {%endfor%}
+
+    {%for prop_name, prop_spec in stinger.properties.items()-%}
+    @property
+    def {{prop_name}}(self) -> {{prop_spec.python_class}} | None:
+        """ Property '{{prop_name}}' getter.
+        """
+        return self._property_{{prop_name}}
+    {%if not prop_spec.read_only %}
+    @{{prop_name}}.setter
+    def {{prop_name}}(self, value: {{prop_spec.python_class}}):
+        """ Serializes and publishes the '{{prop_name}}' property.
+        """
+        if not isinstance(value, {{prop_spec.python_class}}):
+            raise ValueError("The '{{prop_name}}' property must be a {{prop_spec.python_class}}")
+        {%if prop_spec.arg_list | length > 1 -%}
+        serialized = value.model_dump_json(exclude_none=True)
+        {%else-%}
+        serialized = json.dumps({ "{{prop_spec.arg_list[0].name}}": value.{{prop_spec.arg_list[0].name}} })
+        {%endif-%}
+        self._logger.debug("Setting '{{prop_name}}' property to %s", serialized)
+        self._conn.publish("{{prop_spec.update_topic}}", serialized, qos=1)
+    {%endif%}
+    def {{prop_name | snake_case}}_changed(self, handler: {{prop_name | UpperCamelCase}}PropertyUpdatedCallbackType, call_immediately: bool=False):
+        """ Sets a callback to be called when the '{{prop_name}}' property changes.
+        Can be used as a decorator.
+        """
+        self._changed_value_callbacks_for_{{prop_name}}.append(handler)
+        if call_immediately and self._property_{{prop_name}} is not None:
+            handler(self._property_{{prop_name}})
+        return handler
+
+    {%endfor%}
+
+    def _do_callbacks_for(self, callbacks: List[Callable[..., None]], **kwargs):
+        """ Call each callback in the callback dictionary with the provided args.
+        """
+        for cb in callbacks:
+            cb(**kwargs)
+
+    @staticmethod
+    def _filter_for_args(args: Dict[str, Any], allowed_args: List[str]) -> Dict[str, Any]:
+        """ Given a dictionary, reduce the dictionary so that it only has keys in the allowed list.
+        """
+        filtered_args = {}
+        for k, v in args.items():
+            if k in allowed_args:
+                filtered_args[k] = v
+        return filtered_args
+
+    def _receive_message(self, topic: str, payload: str, properties: Dict[str, Any]):
+        """ New MQTT messages are passed to this method, which, based on the topic,
+        calls the appropriate handler method for the message.
+        """
+        self._logger.debug("Receiving message sent to %s", topic)
+        {%if stinger.signals | length > 0 -%}
+        {%for sig_name, sig in stinger.signals.items()-%}
+        # Handle '{{sig_name}}' signal.
+        {%if not loop.first%}el{%endif%}if self._conn.is_topic_sub(topic, "{{sig.topic}}"):
+            if 'ContentType' not in properties or properties['ContentType'] != 'application/json':
+                self._logger.warning("Received '{{sig_name}}' signal with non-JSON content type")
+                return
+            allowed_args = [{%for arg in sig.arg_list%}"{{arg.name}}", {%endfor%}]
+            kwargs = self._filter_for_args(json.loads(payload), allowed_args)
+            {%for arg in sig.arg_list-%}
+            kwargs["{{arg.name}}"] = {{arg.python_class}}(kwargs["{{arg.name}}"]){%if arg.optional %} if kwargs.get("{{arg.name}}") else None {%endif%}
+            {%endfor%}
+            self._do_callbacks_for(self._signal_recv_callbacks_for_{{sig_name | snake_case}}, **kwargs)
+        {%endfor%}{# end signal loop #}
+        
+        {%-else%}pass{%-endif%}
+        {%-for method_name, method in stinger.methods.items()%}
+        # Handle '{{method_name}}' method response.
+        if self._conn.is_topic_sub(topic, f"{{method.response_topic('{self._client_id}')}}"):
+            result_code = MethodResultCode.SUCCESS
+            if "UserProperty" in properties:
+                user_properties = properties["UserProperty"]
+                if "DebugInfo" in user_properties:
+                    self._logger.info("Received Debug Info: %s", user_properties["DebugInfo"])
+                if "ReturnValue" in user_properties:
+                    result_code = MethodResultCode(int(user_properties["ReturnValue"]))
+            response = json.loads(payload)
+            if "CorrelationData" in properties:
+                correlation_id = properties["CorrelationData"].decode()
+                if correlation_id in self._pending_method_responses:
+                    cb = self._pending_method_responses[correlation_id]
+                    del self._pending_method_responses[correlation_id]
+                    cb(response, result_code)
+                else:
+                    self._logger.warning("Correlation id %s was not in the list of pending method responses... %s", correlation_id, [k for k in self._pending_method_responses.keys()])
+            else:
+                self._logger.warning("No correlation data in properties sent to %s... %s", topic, [s for s in properties.keys()])
+        {%endfor%}{# end method loop #}
+        {%-for prop_name, prop_spec in stinger.properties.items()%}
+        # Handle '{{prop_name}}' property change.
+        {%if not loop.first%}el{%endif%}if self._conn.is_topic_sub(topic, "{{prop_spec.value_topic}}"):
+            if 'ContentType' not in properties or properties['ContentType'] != 'application/json':
+                self._logger.warning("Received '{{prop_name}}' property change with non-JSON content type")
+                return
+            try:
+                {%if prop_spec.arg_list | length > 1 -%}
+                prop_value = {{prop_spec.python_class}}.model_validate_json(payload)
+                {%else-%}
+                payload_obj = json.loads(payload)
+                prop_value = {{prop_spec.arg_list[0].python_class}}(payload_obj["{{prop_spec.arg_list[0].name}}"])
+                {%endif-%}
+                self._property_{{prop_name}} = prop_value
+                self._do_callbacks_for(self._changed_value_callbacks_for_{{prop_name}}, value=self._property_{{prop_name}})
+            except Exception as e:
+                self._logger.error("Error processing '{{prop_name}}' property change: %s", e)
+        {%endfor%}{# end property loop #}
+
+    {%for sig_name, sig in stinger.signals.items()%}
+    def receive_{{sig_name | snake_case }}(self, handler: {{sig_name | UpperCamelCase}}SignalCallbackType):
+        """ Used as a decorator for methods which handle particular signals.
+        """
+        self._signal_recv_callbacks_for_{{sig_name | snake_case }}.append(handler)
+        if len(self._signal_recv_callbacks_for_{{sig_name | snake_case}}) == 1:
+            self._conn.subscribe("{{sig.topic}}")
+        return handler
+    {%endfor%}
+
+    {%for method_name, method in stinger.methods.items()%}
+    def {{method_name | snake_case}}(self, {%for arg in method.arg_list%}{{arg.name}}: {{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}) -> futures.Future:
+        """ Calling this initiates a `{{method_name}}` IPC method call.
+        """
+        {%for arg in method.arg_list%}
+        if not isinstance({{arg.name}}, {{arg.python_class}}){%- if not arg.optional -%} and {{arg.name}} is not None{%endif-%}:
+            raise ValueError("The '{{arg.name}}' argument wasn't a {{arg.python_type}}")
+        {%endfor%}
+        fut = futures.Future() # type: futures.Future
+        correlation_id = str(uuid4())
+        self._pending_method_responses[correlation_id] = partial(self._handle_{{method_name | snake_case}}_response, fut)
+        payload = { {%-for arg in method.arg_list%}
+            "{{arg.name}}": {{arg.name}},{%endfor%}
+        }
+        self._conn.publish("{{method.topic}}", json.dumps(payload), qos=2, retain=False,
+                           correlation_id=correlation_id, response_topic=f"{{method.response_topic('{self._client_id}')}}")
+        return fut
+
+    def _handle_{{method_name | snake_case}}_response(self, fut: futures.Future, response_json: Dict[str, Any], return_value: MethodResultCode):
+        """ This called with the response to a `{{method_name}}` IPC method call.
+        """
+        self._logger.debug("Handling {{method_name | snake_case}} response message %s", fut)
+        try:
+            if return_value != MethodResultCode.SUCCESS.value:
+                raise stinger_exception_factory(return_value, response_json['debugResultMessage'] if 'debugResultMessage' in response_json else None)
+            {%if method.return_value is none%}
+            fut.set_result(None)
+            {%elif method.return_value_type == 'struct' %}
+            return_args = self._filter_for_args(response_json, [{%for m in method.return_value%}"{{m.name}}", {%endfor%}])
+            {%for arg in method.return_value-%}
+            return_args["{{arg.name}}"] = {{arg.python_type}}(return_args["{{arg.name}}"])
+            {%endfor%}
+            return_obj = {{method.return_value_python_type}}(**return_args)
+            fut.set_result(return_obj)
+            {%else%}
+            if "{{method.return_value_property_name}}" in response_json:
+                if not isinstance(response_json["{{method.return_value_property_name}}"], {{method.return_value.python_type}}):
+                    raise ValueError("Return value '{{method.return_value_property_name}}'' had wrong type")
+                self._logger.debug("Setting future result")
+                fut.set_result(response_json["{{method.return_value_property_name}}"])
+            else:
+                raise Exception("Response message didn't have the return value")
+            {%endif%}
+        except Exception as e:
+            self._logger.info("Exception while handling {{method_name | snake_case}}", exc_info=e)
+            fut.set_exception(e)
+        if not fut.done():
+            fut.set_exception(Exception("No return value set"))
+    {%endfor%}
+
+class {{stinger.python.client_class_name}}Builder:
+
+    def __init__(self, broker: BrokerConnection):
+        """ Creates a new {{stinger.python.client_class_name}}Builder.
+        """
+        self._conn = broker
+        self._logger = logging.getLogger('{{stinger.python.client_class_name}}Builder')
+        {%for sig_name in stinger.signals.keys()-%}
+        self._signal_recv_callbacks_for_{{sig_name | snake_case}} = [] # type: List[{{sig_name | UpperCamelCase}}SignalCallbackType]
+        {%endfor-%}
+        {%for prop_name in stinger.properties.keys()-%}
+        self._property_updated_callbacks_for_{{prop_name | snake_case}}: list[{{prop_name | UpperCamelCase}}PropertyUpdatedCallbackType] = []
+        {%endfor-%}
+
+    {%for sig_name, sig in stinger.signals.items()%}
+    def receive_{{sig_name | snake_case }}(self, handler):
+        """ Used as a decorator for methods which handle particular signals.
+        """
+        self._signal_recv_callbacks_for_{{sig_name | snake_case }}.append(handler)
+    {%endfor%}
+
+    {%for prop_name, prop in stinger.properties.items()%}
+    def {{prop_name|snake_case}}_updated(self, handler: {{prop_name | UpperCamelCase}}PropertyUpdatedCallbackType):
+        """ Used as a decorator for methods which handle updates to properties.
+        """
+        self._property_updated_callbacks_for_{{prop_name | snake_case}}.append(handler)
+    {%endfor%}
+
+    def build(self) -> {{stinger.python.client_class_name}}:
+        """ Builds a new {{stinger.python.client_class_name}}.
+        """
+        self._logger.debug("Building {{stinger.python.client_class_name}}")
+        client = {{stinger.python.client_class_name}}(self._conn)
+        {%for sig_name, sig in stinger.signals.items()%}
+        for cb in self._signal_recv_callbacks_for_{{sig_name | snake_case }}:
+            client.receive_{{sig_name | snake_case}}(cb)
+        {%endfor%}
+        {%for prop_name, prop in stinger.properties.items()%}
+        for cb in self._property_updated_callbacks_for_{{prop_name | snake_case}}:
+            client.{{prop_name | snake_case}}_changed(cb)
+        {%endfor%}
+        return client
+
+
+if __name__ == '__main__':
+    import signal
+
+    {%set broker = stinger.get_example_broker()%}from connection import {{broker.class_name}}
+    conn = {{broker.class_name}}({%if broker.hostname is none%}'localhost', 1883{%endif%})
+    client_builder = {{stinger.python.client_class_name}}Builder(conn)
+    {%for sig_name, sig in stinger.signals.items()%}
+    @client_builder.receive_{{sig_name | snake_case }}
+    def print_{{sig_name}}_receipt({%for arg in sig.arg_list%}{{arg.name}}: {{arg.python_type}}{%if not loop.last%}, {%endif%}{%endfor%}):
+        """{{sig.description}}
+        {%for arg in sig.arg_list-%}
+        @param {{arg.name}} {{arg.python_type}} {{arg.description or ''}}
+        {%endfor%}"""
+        print(f"Got a '{{sig_name}}' signal: {%for arg in sig.arg_list%}{{arg.name}}={ {{arg.name}} } {%endfor%}")
+    {%endfor%}
+    {%for prop_name, prop in stinger.properties.items()%}
+    @client_builder.{{prop_name | snake_case}}_updated
+    def print_new_{{prop_name}}_value(value: {{prop.python_class}}):
+        """{{prop.description}}
+        """
+        print(f"Property '{{prop_name}}' has been updated to: {value}")
+    {%endfor%}
+
+    client = client_builder.build()
+    {%if stinger.methods | length > 0 %}
+    {%-for method_name, method in stinger.methods.items()%}
+    print("Making call to '{{method_name|snake_case}}'")
+    future = client.{{method_name|snake_case}}({%for arg in method.arg_list%}{{arg.name}}={{arg.get_random_example_value()}}{%if not loop.last%}, {%endif%}{%endfor%})
+    try:
+        print(f"RESULT:  {future.result(5)}")
+    except futures.TimeoutError:
+        print(f"Timed out waiting for response to '{{method_name|snake_case}}' call")
+    {%endfor%}
+    {%endif%}
+
+    print("Ctrl-C will stop the program.")
+    signal.pause()

stingeripc/templates/python/connection.py.jinja2

@@ -0,0 +1,164 @@
+
+import logging
+from typing import Callable, Optional, Tuple, Any, Union
+from paho.mqtt.client import Client as MqttClient, topic_matches_sub
+from paho.mqtt.enums import MQTTProtocolVersion, CallbackAPIVersion
+from paho.mqtt.properties import Properties as MqttProperties
+from paho.mqtt.packettypes import PacketTypes
+from queue import Queue, Empty
+from abc import ABC, abstractmethod
+from method_codes import *
+
+
+logging.basicConfig(level=logging.DEBUG)
+
+MessageCallback = Callable[[str, str, dict[str, Any]], None]
+
+class BrokerConnection(ABC):
+    
+    @abstractmethod
+    def publish(self, topic: str, msg: str, qos: int=1, retain: bool=False,
+            correlation_id: Union[str, bytes, None] = None, response_topic: Optional[str] = None,
+            return_value: Optional[MethodResultCode] = None, debug_info: Optional[str] = None):
+        pass
+
+    @abstractmethod
+    def subscribe(self, topic) -> int:
+        pass
+
+    @abstractmethod
+    def set_message_callback(self, callback: MessageCallback) -> None:
+        pass
+
+    @abstractmethod
+    def is_topic_sub(self, topic: str, sub: str) -> bool:
+        pass
+
+    @abstractmethod
+    def set_last_will(self, topic: str, payload: Optional[str]=None, qos: int=1, retain: bool=True):
+        pass
+
+
+{%for broker in stinger.brokers.values()%}
+class {{broker.class_name}}(BrokerConnection):
+
+    class PendingSubscription:
+        def __init__(self, topic: str, subscription_id: int):
+            self.topic = topic
+            self.subscription_id
+
+    def __init__(self{%if broker.hostname is none%}, host: str, port: int{%endif%}):
+        self._logger = logging.getLogger('Connection')
+        self._logger.setLevel(logging.DEBUG)
+        self._host: str = {%if broker.hostname is none %}host{%else%}"{{broker.hostname}}"{%endif%}
+        self._port: int = {%if broker.port is none %}port{%else%}{{broker.port}}{%endif%}
+        self._last_will: Optional[Tuple[str, Optional[str], int, bool]] = None
+        self._queued_messages = Queue() # type: Queue[Tuple[str, str, int, bool, MqttProperties]]
+        self._queued_subscriptions = Queue() # type: Queue[{{broker.class_name}}.PendingSubscription]
+        self._connected: bool = False
+        self._client = MqttClient(CallbackAPIVersion.VERSION2, protocol=MQTTProtocolVersion.MQTTv5)
+        self._client.on_connect = self._on_connect
+        self._client.on_message = self._on_message
+        self._client.connect(self._host, self._port)
+        self._message_callback: Optional[MessageCallback] = None
+        self._client.loop_start()
+        self._next_subscription_id = 10
+
+    def __del__(self):
+        if self._last_will is not None:
+            self._client.publish(*self._last_will).wait_for_publish()
+        self._client.disconnect()
+        self._client.loop_stop()
+
+    def get_next_subscription_id(self) -> int:
+        sub_id = self._next_subscription_id
+        self._next_subscription_id += 1
+        return sub_id
+
+    def set_last_will(self, topic: str, payload: Optional[str]=None, qos: int=1, retain: bool=True):
+        self._last_will = (topic, payload, qos, retain)
+        self._client.will_set(*self._last_will)
+
+    def set_message_callback(self, callback: MessageCallback):
+        self._message_callback = callback
+
+    def _on_message(self, client, userdata, msg):
+        if self._message_callback:
+            properties = msg.properties.__dict__ if hasattr(msg, 'properties') else {}
+            if "UserProperty" in properties:
+                properties["UserProperty"] = dict(properties["UserProperty"])
+            self._message_callback(msg.topic, msg.payload.decode(), properties)
+
+    def _on_connect(self, client, userdata, flags, reason_code, properties):
+        if reason_code == 0:  # Connection successful 
+            self._connected = True
+            self._logger.info("Connected to %s:%d", self._host, self._port)
+            while not self._queued_subscriptions.empty():
+                try:
+                    pending_subscr = self._queued_subscriptions.get_nowait()
+                except Empty:
+                    break
+                else:
+                    self._logger.debug("Connected and subscribing to %s", pending_subscr.topic)
+                    sub_props = MqttProperties(PacketTypes.SUBSCRIBE)
+                    sub_props.SubscriptionIdentifier = pending_subscr.subscription_id
+                    self._client.subscribe(pending_subscr.topic, qos=1, properties=sub_props)
+            while not self._queued_messages.empty():
+                try:
+                    msg = self._queued_messages.get_nowait()
+                except Empty:
+                    break
+                else:
+                    self._logger.info(f"Publishing queued up message")
+                    self._client.publish(*msg)
+        else:
+            self._logger.error("Connection failed with reason code %d", reason_code)
+            self._connected = False
+        
+    
+    def publish(self, topic: str, msg: str, qos: int=1, retain: bool=False,
+            correlation_id: Union[str, bytes, None] = None, response_topic: Optional[str] = None,
+            return_value: Optional[MethodResultCode] = None, debug_info: Optional[str] = None):
+        """ Publish a message to mqtt.
+        """
+        properties = MqttProperties(PacketTypes.PUBLISH)
+        properties.ContentType = "application/json"
+        if isinstance(correlation_id, str):
+            properties.CorrelationData = correlation_id.encode('utf-8')
+        elif isinstance(correlation_id, bytes):
+            properties.CorrelationData = correlation_id
+        if response_topic is not None:
+            properties.ResponseTopic = response_topic
+        user_properties = []
+        if return_value is not None:
+            user_properties.append(("ReturnValue", str(return_value.value)))
+        if debug_info is not None:
+            user_properties.append(("DebugInfo", debug_info))
+        if len(user_properties) > 0:
+            properties.UserProperty = user_properties
+        if self._connected:
+            self._logger.info("Publishing %s", topic)
+            self._client.publish(topic, msg, qos, retain, properties)
+        else:
+            self._logger.info("Queueing %s for publishing later", topic)
+            self._queued_messages.put((topic, msg, qos, retain, properties))
+
+    def subscribe(self, topic: str) -> int:
+        """ Subscribes to a topic. If the connection is not established, the subscription is queued.
+        Returns the subscription ID.
+        """
+        sub_id = self.get_next_subscription_id()
+        if self._connected:
+            self._logger.debug("Subscribing to %s", topic)
+            sub_props = MqttProperties(PacketTypes.SUBSCRIBE)
+            sub_props.SubscriptionIdentifier = sub_id
+            self._client.subscribe(topic, qos=1, properties=sub_props)
+        else:
+            self._logger.debug("Pending subscription to %s", topic)
+            self._queued_subscriptions.put(self.PendingSubscription(topic, sub_id))
+        return sub_id
+    
+    def is_topic_sub(self, topic: str, sub: str) -> bool:
+        return topic_matches_sub(sub, topic)
+
+{%endfor%}

stingeripc/templates/python/interface_types.py.jinja2

@@ -0,0 +1,48 @@
+"""
+DO NOT MODIFY THIS FILE.  It is automatically generated and changes will be over-written
+on the next generation.
+
+It contains enumerations used by the {{stinger.name}} interface.
+"""
+from pydantic import BaseModel
+{%if stinger.uses_enums()%}from enum import IntEnum{%endif%}
+
+{%for ie_name, ie in stinger.enums.items() %}
+class {{ie_name | UpperCamelCase }}(IntEnum):
+    """ Interface enum `{{ie_name}}`."""
+    {%-for value in ie.values %}
+    {{value | CONST_CASE}} = {{loop.index}}
+    {%-endfor%}
+{%endfor%}
+
+{%-for istruct_name, istruct in stinger.structs.items() %}
+class {{istruct_name | UpperCamelCase }}(BaseModel):
+    """ Interface struct `{{istruct_name}}`. """
+    {%-for arg in istruct.members%}
+    {{arg.name}}: {{arg.python_local_type}}
+    {%-endfor%}
+{%endfor%}
+
+{%-for method_name, method in stinger.methods.items()%}
+{%-if method.return_value_type == 'struct'%}
+class {{method.return_value_python_local_type}}(BaseModel):
+    """ Interface method `{{method_name}}` return value struct. """
+    {%-for arg in method.return_value%}
+    {{arg.name}}: {{arg.python_local_type}}
+    {%-endfor%}
+{%endif-%}
+{%endfor%}
+
+{%-for prop_name, prop in stinger.properties.items()%}{%if prop.arg_list | length > 1%}
+class {{prop.python_local_type}}(BaseModel):
+    """ Interface property `{{prop_name}}` (multi-value struct)."""
+    {%for arg in prop.arg_list%}
+    {%-if arg.arg_type.name.lower() == 'primitive' -%}
+    {{arg.name}}: {{arg.python_local_type}}
+    {%elif arg.arg_type.name.lower() == 'enum'-%}
+    {{arg.name}}: {{arg.python_local_type}}
+    {%elif arg.arg_type.name.lower() == 'struct'-%}
+    {{arg.name}}: {{arg.python_local_type}}
+    {%endif-%}
+    {%endfor%}
+{%endif%}{%endfor%}