pyqttier 0.1.0__py3-none-any.whl

pyqttier/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from pyqttier!"

pyqttier/connection.py

@@ -0,0 +1,200 @@
+from concurrent.futures import Future
+import logging
+import threading
+import uuid
+from typing import Callable, Optional, Tuple, Any, Union, List, Dict
+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 .interface import IBrokerConnection, MessageCallback
+from .transport import MqttTransport
+from .message import Message
+from .lwt import OnlinePresence
+from dataclasses import dataclass
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+class Mqtt5Connection(IBrokerConnection):
+
+    @dataclass
+    class PendingSubscription:
+        topic: str
+        subscription_id: int
+
+    @dataclass
+    class PendingPublish:
+        msg: Message
+        future: Future
+
+    def __init__(
+        self,
+        transport: MqttTransport,
+        client_id: Optional[str] = None,
+        lwt: Optional[OnlinePresence] = None,
+    ):
+        self._logger = logging.getLogger("MqttConnection")
+        self._transport = transport
+        self._client_id = client_id or str(uuid.uuid4())
+        self._queued_messages = Queue()  # type: Queue[Mqtt5Connection.PendingPublish]
+        self._queued_subscriptions = (
+            Queue()
+        )  # type: Queue[Mqtt5Connection.PendingSubscription]
+        self._connected: bool = False
+
+        lwt_properties = MqttProperties(PacketTypes.PUBLISH)
+        lwt_properties.ContentType = "application/json"
+        lwt_properties.MessageExpiryInterval = 60 * 60 * 24  # 1 day
+        self._lwt = lwt or OnlinePresence.default(self._client_id)
+
+        self._connect_inner_mqtt_client()
+
+        self._message_handling_lock = threading.Lock()
+        with self._message_handling_lock:
+            self._subscription_callbacks = dict()  # type: Dict[int, MessageCallback]
+            self._message_callbacks = []  # type: List[MessageCallback]
+
+        self._publishing_lock = threading.Lock()
+        with self._publishing_lock:
+            self._publish_futures = dict()  # type: Dict[int, Future]
+
+        self._client.loop_start()
+        self._next_subscription_id = 10
+
+    def _connect_inner_mqtt_client(self):
+        """
+        Private method to be called from constructor only.
+        """
+        self._client = MqttClient(
+            CallbackAPIVersion.VERSION2,
+            protocol=MQTTProtocolVersion.MQTTv5,
+            transport=self._transport.transport.value,
+            client_id=self._client_id,
+            reconnect_on_failure=True,
+        )
+        self._client.on_connect = self._on_connect
+        self._client.on_message = self._on_message
+        self._client.on_publish = self.on_publish_complete
+        self._client.will_set(**self._lwt.online.paho_kwargs())
+        host = self._transport.host_or_path or "localhost"
+        self._client.connect(host, self._transport.port)
+
+    def __del__(self):
+        if self._lwt is not None:
+            self._client.publish(**self._lwt.offline.paho_kwargs()).wait_for_publish()
+        self._client.disconnect()
+        self._client.loop_stop()
+
+    @property
+    def online_topic(self) -> str:
+        return self._lwt.topic
+
+    @property
+    def client_id(self) -> str:
+        return self._client_id
+
+    def is_connected(self) -> bool:
+        return self._connected
+
+    def get_next_subscription_id(self) -> int:
+        sub_id = self._next_subscription_id
+        self._next_subscription_id += 1
+        return sub_id
+
+    def add_message_callback(self, callback: MessageCallback):
+        self._message_callbacks.append(callback)
+
+    def _on_message(self, client, userdata, msg):
+        self._logger.debug("Got a message to %s : %s", msg.topic, msg.payload.decode())
+        message = Message.from_paho_message(msg)
+        if message.subscription_id is not None:
+            sub_id = message.subscription_id
+            with self._message_handling_lock:
+                if sub_id in self._subscription_callbacks:
+                    self._subscription_callbacks[sub_id](message)
+                    return
+        with self._message_handling_lock:
+            for callback in self._message_callbacks:
+                callback(message)
+
+    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._transport.host_or_path, self._transport.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")
+                    pub_info = self._client.publish(**msg.msg.paho_kwargs())
+                    with self._publishing_lock:
+                        self._publish_futures[pub_info.mid] = msg.future
+
+            self._client.publish(**self._lwt.online.paho_kwargs())
+        else:
+            self._logger.error(
+                "Connection failed with reason code %s", str(reason_code)
+            )
+            self._connected = False
+
+    def on_publish_complete(
+        self, client, userdata, mid, reason_code=None, properties=None
+    ):
+        with self._publishing_lock:
+            if mid in self._publish_futures:
+                fut = self._publish_futures.pop(mid)
+                fut.set_result(None)
+
+    def publish(self, message: Message) -> Future:
+        """Publish a message to mqtt, or queue it if not connected yet.  Returns a Future that completes when the message is published."""
+        fut = Future()  # type: Future
+        if self._connected:
+            self._logger.info("Publishing %s", message.topic)
+            msg_info = self._client.publish(**message.paho_kwargs())
+            with self._publishing_lock:
+                self._publish_futures[msg_info.mid] = fut
+        else:
+            self._logger.info("Queueing %s for publishing later", message.topic)
+            pending_pub = self.PendingPublish(msg=message, future=fut)
+            self._queued_messages.put(pending_pub)
+        return fut
+
+    def subscribe(self, topic: str, callback: Optional[MessageCallback] = None) -> 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))
+        if callback is not None:
+            self._subscription_callbacks[sub_id] = callback
+        return sub_id
+
+    def is_topic_sub(self, topic: str, sub: str) -> bool:
+        return topic_matches_sub(sub, topic)

pyqttier/interface.py

@@ -0,0 +1,57 @@
+from abc import ABC, abstractmethod
+from typing import Callable, Dict, Any, Union, Optional
+from .message import Message
+from concurrent.futures import Future
+
+MessageCallback = Callable[[Message], None]
+
+
+class IBrokerConnection(ABC):
+
+    @abstractmethod
+    def publish(self, message: Message) -> Future:
+        """
+        Publishes a message to the provided topic with the provided parameters.  If the connection to the broker is not established,
+        the message may be queued until the connection is established.
+        """
+        pass
+
+    @abstractmethod
+    def subscribe(self, topic: str, callback: Optional[MessageCallback] = None) -> int:
+        """
+        Subscribes to the provided topic.  May queue the subscription until the connection to the broker is established.
+        When a message is received on the topic, the provided callback will be executed if provided.
+        Returns a subscription identifier for the subscription.
+        """
+        pass
+
+    @abstractmethod
+    def add_message_callback(self, callback: MessageCallback) -> None:
+        """
+        The provided callback is called for all received messages that do not have a specific callback registered via the subscribe method.
+        """
+        pass
+
+    @abstractmethod
+    def is_topic_sub(self, topic: str, sub: str) -> bool:
+        """Returns True if the provided topic matches the provided subscription filter."""
+        pass
+
+    @property
+    @abstractmethod
+    def online_topic(self) -> Optional[str]:
+        pass
+
+    @property
+    @abstractmethod
+    def client_id(self) -> str:
+        pass
+
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """Returns True if the connection to the broker is established."""
+        pass
+
+    def unpublish_retained(self, topic):
+        msg = Message(topic=topic, payload=b"", qos=1, retain=True)
+        self.publish(msg)

pyqttier/lwt.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+from .message import Message
+
+
+class OnlinePresence(BaseModel):
+    topic: str
+    online: Message
+    offline: Message
+
+    def __post_init__(self):
+        self.online.topic = self.topic
+        self.offline.topic = self.topic
+
+    @classmethod
+    def default(cls, client_id: str) -> "OnlinePresence":
+        online_topic = f"client/{client_id}/online"
+        online_msg = Message(
+            topic=online_topic, payload=b'{"online":true}', qos=1, retain=True
+        )
+        offline_msg = Message(
+            topic=online_topic, payload=b'{"online":false}', qos=1, retain=True
+        )
+        return cls(topic=online_topic, online=online_msg, offline=offline_msg)

pyqttier/message.py

@@ -0,0 +1,223 @@
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Union, Any
+from paho.mqtt.client import MQTTMessage
+from paho.mqtt.properties import Properties as MqttProperties
+from paho.mqtt.packettypes import PacketTypes
+from pydantic import BaseModel
+from enum import Enum
+import uuid
+
+
+@dataclass
+class Message:
+    topic: str
+    payload: bytes
+    qos: int
+    retain: bool = False
+    content_type: Optional[str] = None
+    correlation_data: Optional[bytes] = None
+    response_topic: Optional[str] = None
+    subscription_id: Optional[int] = None  # Ignored on publish
+    message_expiry_interval: Optional[int] = None
+    user_properties: Optional[Dict[str, str]] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if self.user_properties is None:
+            self.user_properties = dict()
+
+    def paho_kwargs(self) -> Dict[str, Any]:
+        props = MqttProperties(PacketTypes.PUBLISH)
+        if self.content_type is not None:
+            props.ContentType = self.content_type
+        if self.correlation_data is not None:
+            props.CorrelationData = self.correlation_data
+        if self.response_topic is not None:
+            props.ResponseTopic = self.response_topic
+        if self.message_expiry_interval is not None:
+            props.MessageExpiryInterval = self.message_expiry_interval
+        if self.user_properties is not None and len(self.user_properties) > 0:
+            props.UserProperty = list(self.user_properties.items())
+        kwargs = {
+            "topic": self.topic,
+            "payload": self.payload,
+            "qos": self.qos,
+            "retain": self.retain,
+            "properties": props,
+        }
+        return kwargs
+
+    @classmethod
+    def from_paho_message(cls, paho_msg: MQTTMessage) -> "Message":
+        msg_obj = cls(
+            topic=paho_msg.topic,
+            payload=paho_msg.payload,
+            qos=paho_msg.qos,
+            retain=paho_msg.retain,
+        )
+        properties = (
+            paho_msg.properties.__dict__ if hasattr(paho_msg, "properties") else {}
+        )
+        if "UserProperty" in properties:
+            msg_obj.user_properties = dict(properties["UserProperty"])
+        if "ContentType" in properties:
+            msg_obj.content_type = properties["ContentType"]
+        if "CorrelationData" in properties:
+            msg_obj.correlation_data = properties["CorrelationData"]
+        if "ResponseTopic" in properties:
+            msg_obj.response_topic = properties["ResponseTopic"]
+        if "MessageExpiryInterval" in properties:
+            msg_obj.message_expiry_interval = properties["MessageExpiryInterval"]
+        return msg_obj
+
+    @classmethod
+    def status_message(
+        cls, topic, status_message: BaseModel, expiry_seconds: int
+    ) -> "Message":
+        return cls(
+            topic=topic,
+            payload=status_message.model_dump_json(by_alias=True).encode("utf-8"),
+            qos=1,
+            retain=True,
+            message_expiry_interval=expiry_seconds,
+        )
+
+    @classmethod
+    def error_response_message(
+        cls,
+        topic: str,
+        return_code: int,
+        correlation_id: Union[str, bytes],
+        debug_info: Optional[str] = None,
+    ) -> "Message":
+        msg_obj = cls(
+            topic=topic,
+            payload=b"{}",
+            qos=1,
+            retain=False,
+            correlation_data=(
+                correlation_id.encode("utf-8")
+                if isinstance(correlation_id, str)
+                else correlation_id
+            ),
+            user_properties={"ReturnCode": str(return_code)},
+        )
+        if (
+            debug_info is not None and msg_obj.user_properties is not None
+        ):  # user_properties should never be None here, but checking to satisfy type checker
+            msg_obj.user_properties["DebugInfo"] = debug_info
+        return msg_obj
+
+    @classmethod
+    def response_message(
+        cls,
+        response_topic: str,
+        response_obj: BaseModel,
+        return_code: int,
+        correlation_id: Union[str, bytes],
+    ) -> "Message":
+        msg_obj = cls(
+            topic=response_topic,
+            payload=response_obj.model_dump_json(by_alias=True).encode("utf-8"),
+            qos=1,
+            retain=False,
+            correlation_data=(
+                correlation_id.encode("utf-8")
+                if isinstance(correlation_id, str)
+                else correlation_id
+            ),
+            user_properties={"ReturnCode": str(return_code)},
+        )
+        return msg_obj
+
+    @classmethod
+    def property_state_message(
+        cls, topic: str, state_obj: BaseModel, state_version: Optional[int] = None
+    ) -> "Message":
+        msg_obj = cls(
+            topic=topic,
+            payload=state_obj.model_dump_json(by_alias=True).encode("utf-8"),
+            qos=1,
+            retain=True,
+        )
+        if state_version is not None:
+            msg_obj.user_properties = {"PropertyVersion": str(state_version)}
+        return msg_obj
+
+    @classmethod
+    def property_update_request_message(
+        cls,
+        topic: str,
+        property_obj: BaseModel,
+        version: str,
+        response_topic: str,
+        correlation_id: Union[str, bytes, None] = None,
+    ) -> "Message":
+        msg_obj = cls(
+            topic=topic,
+            payload=property_obj.model_dump_json(by_alias=True).encode("utf-8"),
+            qos=1,
+            retain=False,
+            response_topic=response_topic,
+            correlation_data=(
+                correlation_id.encode("utf-8")
+                if isinstance(correlation_id, str)
+                else correlation_id
+            ),
+            user_properties={"PropertyVersion": str(version)},
+        )
+        return msg_obj
+
+    @classmethod
+    def property_response_message(
+        cls,
+        response_topic: str,
+        property_obj: BaseModel,
+        version: str,
+        return_code: int,
+        correlation_id: Union[str, bytes],
+        debug_info: Optional[str] = None,
+    ) -> "Message":
+        msg_obj = cls(
+            topic=response_topic,
+            payload=property_obj.model_dump_json(by_alias=True).encode("utf-8"),
+            qos=1,
+            retain=False,
+            correlation_data=(
+                correlation_id.encode("utf-8")
+                if isinstance(correlation_id, str)
+                else correlation_id
+            ),
+            user_properties={
+                "ReturnCode": str(return_code),
+                "PropertyVersion": str(version),
+            },
+        )
+        if (
+            debug_info is not None and msg_obj.user_properties is not None
+        ):  # user_properties should never be None here, but checking to satisfy type checker
+            msg_obj.user_properties["DebugInfo"] = debug_info
+        return msg_obj
+
+    @classmethod
+    def publish_request(
+        cls,
+        topic: str,
+        request_obj: BaseModel,
+        response_topic: str,
+        correlation_id: Union[str, bytes, None] = None,
+    ) -> "Message":
+        if correlation_id is None:
+            correlation_id = str(uuid.uuid4())
+        msg_obj = cls(
+            topic=topic,
+            payload=request_obj.model_dump_json(by_alias=True).encode("utf-8"),
+            qos=1,
+            retain=False,
+            response_topic=response_topic,
+            correlation_data=(
+                correlation_id.encode("utf-8")
+                if isinstance(correlation_id, str)
+                else correlation_id
+            ),
+        )
+        return msg_obj

pyqttier/mock.py

@@ -0,0 +1,144 @@
+from concurrent.futures import Future
+from typing import Optional, Dict, List, Callable, Tuple
+from copy import copy
+from .interface import IBrokerConnection, MessageCallback
+from .message import Message
+import threading
+
+
+class MockConnection(IBrokerConnection):
+    """
+    Mock implementation of IBrokerConnection for testing purposes.
+    Simulates broker behavior without requiring an actual MQTT broker.
+    """
+
+    def __init__(self):
+        self._connected = True
+        self._subscriptions = (
+            {}
+        )  # type: Dict[int, Tuple[str, Optional[MessageCallback]]]
+        self._message_callbacks = []  # type: List[MessageCallback]
+        self._published_messages = []  # type: List[Message]
+        self._next_subscription_id = 1  # type: int
+        self._lock = threading.Lock()
+
+    @property
+    def client_id(self) -> str:
+        return "mock-client"
+    
+    @property
+    def online_topic(self) -> Optional[str]:
+        return None
+
+    @property
+    def published_messages(self) -> List[Message]:
+        """Returns list of all published messages for testing verification."""
+        with self._lock:
+            return self._published_messages.copy()
+
+    def clear_published_messages(self) -> None:
+        """Clears the list of published messages."""
+        with self._lock:
+            self._published_messages.clear()
+
+    def set_connected(self, connected: bool) -> "MockConnection":
+        """Sets the connection status for testing."""
+        with self._lock:
+            self._connected = connected
+        return self
+
+    def simulate_message(self, message: Message) -> None:
+        """
+        Simulates receiving a message from the broker.
+        Triggers appropriate callbacks based on subscriptions.
+        """
+        with self._lock:
+            # Check subscription-specific callbacks
+            for sub_id, (topic_filter, callback) in self._subscriptions.items():
+                if self.is_topic_sub(message.topic, topic_filter):
+                    if callback is not None:
+                        receiving_msg = copy(message)
+                        receiving_msg.subscription_id = sub_id
+                        callback(receiving_msg)
+                        return
+
+            # If no specific callback matched, call general message callbacks
+            for callback in self._message_callbacks:
+                callback(message)
+
+    def publish(self, message: Message) -> Future:
+        """
+        Records the published message and returns a completed Future.
+        """
+        with self._lock:
+            self._published_messages.append(message)
+
+        future: Future = Future()
+        future.set_result(None)
+        return future
+
+    def subscribe(self, topic: str, callback: Optional[MessageCallback] = None) -> int:
+        """
+        Registers a subscription and returns a subscription ID.
+        """
+        with self._lock:
+            sub_id = self._next_subscription_id
+            self._next_subscription_id += 1
+            self._subscriptions[sub_id] = (topic, callback)
+            return sub_id
+
+    def add_message_callback(self, callback: MessageCallback) -> None:
+        """
+        Adds a callback for messages without specific subscription callbacks.
+        """
+        with self._lock:
+            self._message_callbacks.append(callback)
+
+    def is_topic_sub(self, topic: str, sub: str) -> bool:
+        """
+        Simple topic matching implementation.
+        Supports MQTT wildcards: + (single level) and # (multi level).
+        """
+        topic_parts = topic.split("/")
+        sub_parts = sub.split("/")
+
+        # # must be last and matches everything after
+        if "#" in sub_parts:
+            hash_idx = sub_parts.index("#")
+            if hash_idx != len(sub_parts) - 1:
+                return False  # # must be last
+            sub_parts = sub_parts[:hash_idx]
+            topic_parts = topic_parts[:hash_idx]
+
+        if len(topic_parts) != len(sub_parts):
+            return False
+
+        for topic_part, sub_part in zip(topic_parts, sub_parts):
+            if sub_part == "+":
+                continue  # + matches any single level
+            if topic_part != sub_part:
+                return False
+
+        return True
+
+    def is_connected(self) -> bool:
+        """Returns the connection status."""
+        with self._lock:
+            return self._connected
+
+    def unsubscribe(self, subscription_id: int) -> None:
+        """
+        Helper method to unsubscribe by subscription ID.
+        Not part of the interface but useful for testing.
+        """
+        with self._lock:
+            if subscription_id in self._subscriptions:
+                del self._subscriptions[subscription_id]
+
+    def get_subscription_count(self) -> int:
+        """
+        Returns the number of active subscriptions.
+        Helper method for testing.
+        """
+        with self._lock:
+            return len(self._subscriptions)

pyqttier/transport.py

@@ -0,0 +1,27 @@
+from enum import Enum
+from typing import Optional
+
+
+class MqttTransportType(Enum):
+    """Defines ways to connect to an MQTT broker."""
+
+    TCP = "tcp"
+    WEBSOCKET = "websockets"
+    UNIX = "unix"
+
+
+class MqttTransport:
+    """Defines the transport parameters for connecting to an MQTT broker."""
+
+    def __init__(
+        self,
+        transport_type: MqttTransportType,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        socket_path: Optional[str] = None,
+    ):
+        self.transport = transport_type
+        self.host_or_path = (
+            socket_path if transport_type == MqttTransportType.UNIX else host
+        )
+        self.port = 0 if transport_type == MqttTransportType.UNIX else (port or 1883)

pyqttier-0.1.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: pyqttier
+Version: 0.1.0
+Summary: Add your description here
+Author-email: Jacob Brunson <github@jacobbrunson.com>
+License-File: LICENSE
+Requires-Python: >=3.7
+Requires-Dist: paho-mqtt>=2.1.0
+Requires-Dist: pydantic>=2.5.3
+Description-Content-Type: text/markdown
+
+# PyQTTier
+
+A Python MQTT client library providing a clean, type-safe wrapper around paho-mqtt with support for MQTT 5.0 features.
+
+## Features
+
+- **MQTT 5.0 Support** - Full support for MQTT 5.0 protocol features including message properties, correlation data, and response topics
+- **Type Safety** - Strongly typed with mypy-checked type hints for reliability
+- **Multiple Transports** - Supports TCP, WebSocket, and Unix socket connections
+- **Mock Implementation** - Built-in `MockConnection` for easy testing without a broker
+- **Python 3.7+** - Compatible with Python 3.7 through 3.12
+
+## Installation
+
+```bash
+pip install pyqttier
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from pyqttier.connection import Mqtt5Connection
+from pyqttier.transport import MqttTransport, MqttTransportType
+from pyqttier.message import Message
+
+# Connect to broker
+transport = MqttTransport(MqttTransportType.TCP, host="localhost", port=1883)
+conn = Mqtt5Connection(transport=transport, client_id="my-client")
+
+# Subscribe to a topic
+def on_message(msg: Message):
+    print(f"Received: {msg.payload.decode()}")
+
+conn.subscribe("sensors/temperature", callback=on_message)
+
+# Publish a message
+msg = Message(topic="sensors/temperature", payload=b"23.5", qos=1)
+conn.publish(msg)
+```
+
+### Testing with MockConnection
+
+```python
+from pyqttier.mock import MockConnection
+from pyqttier.message import Message
+
+# Create mock connection for testing
+conn = MockConnection()
+
+# Publish and verify
+conn.publish(Message(topic="test", payload=b"data", qos=1))
+assert len(conn.published_messages) == 1
+assert conn.published_messages[0].topic == "test"
+```
+
+## Examples
+
+See the [examples/](examples/) directory for more detailed usage examples:
+
+- `usage_example.py` - Real broker connections, wildcards, request-response patterns
+- `mock_example.py` - Testing with MockConnection
+
+## Development
+
+```bash
+# Type checking
+uv run mypy --check-untyped-defs ./src/
+
+# Unit tests
+uv run pytest
+```
+
+## License
+
+See [LICENSE](LICENSE) file for details.

pyqttier-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyqttier/__init__.py,sha256=UvsVYguOyK6Sj2n7AnSFT1kfZeYwCtejhnKw6f_hvCY,54
+pyqttier/connection.py,sha256=b3TPcDN_-msTbqOwbsWnga3igxnBqRhbVFITuDuMnew,7917
+pyqttier/interface.py,sha256=jqA8Q7TecWjPdMLfx13xzJIoWIXmUSs2Q2YHbSePvyQ,1887
+pyqttier/lwt.py,sha256=NNTB8ZxJivC4aCz2lZaJJ14RQ_nKbbwto-8eAtpHKVc,707
+pyqttier/message.py,sha256=7gG5HATDXxl8YdQG8nQ3_gU8SqhEV09YkQvhRgHD-VQ,7558
+pyqttier/mock.py,sha256=LvMmlKUdHjgPtCoxn1okfuYAZXdI6mQLUTmfS5eoDOE,4952
+pyqttier/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyqttier/transport.py,sha256=Lf898T4wre6rJu2yv2xFs9XxnTvzI9xEKIab_RSssTU,742
+pyqttier-0.1.0.dist-info/METADATA,sha256=I8VoJ-nQui3ksgaoRHuwD01HDH4pc7n4qagdk6aFduA,2315
+pyqttier-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pyqttier-0.1.0.dist-info/licenses/LICENSE,sha256=_T-8ExmblJbhv-1AxC6XDVEHg1JdJA-126NvRiMqS-I,1070
+pyqttier-0.1.0.dist-info/RECORD,,

pyqttier-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyqttier-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jacob Brunson
+
+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.