updates2mqtt 1.3.4__py3-none-any.whl

updates2mqtt/mqtt.py

@@ -0,0 +1,286 @@
+import asyncio
+import json
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+import paho.mqtt.client as mqtt
+import paho.mqtt.subscribeoptions
+import structlog
+from paho.mqtt.client import MQTTMessage
+from paho.mqtt.enums import CallbackAPIVersion
+from paho.mqtt.properties import Properties
+from paho.mqtt.reasoncodes import ReasonCode
+
+from updates2mqtt.model import Discovery, ReleaseProvider
+
+from .config import HomeAssistantConfig, MqttConfig, NodeConfig
+from .hass_formatter import hass_format_config, hass_format_state
+
+log = structlog.get_logger()
+
+
+@dataclass
+class LocalMessage:
+    topic: str | None = field(default=None)
+    payload: str | None = field(default=None)
+
+
+class MqttClient:
+    def __init__(self, cfg: MqttConfig, node_cfg: NodeConfig, hass_cfg: HomeAssistantConfig) -> None:
+        self.cfg: MqttConfig = cfg
+        self.node_cfg: NodeConfig = node_cfg
+        self.hass_cfg: HomeAssistantConfig = hass_cfg
+        self.providers_by_topic: dict[str, ReleaseProvider] = {}
+        self.event_loop: asyncio.AbstractEventLoop | None = None
+        self.client: mqtt.Client | None = None
+        self.log = structlog.get_logger().bind(host=cfg.host, integration="mqtt")
+
+    def start(self, event_loop: asyncio.AbstractEventLoop | None = None) -> None:
+        logger = self.log.bind(action="start")
+        try:
+            self.event_loop = event_loop or asyncio.get_event_loop()
+            self.client = mqtt.Client(
+                callback_api_version=CallbackAPIVersion.VERSION2,
+                client_id=f"updates2mqtt_{self.node_cfg.name}",
+                clean_session=True,
+            )
+            self.client.username_pw_set(self.cfg.user, password=self.cfg.password)
+            self.client.connect(host=self.cfg.host, port=self.cfg.port, keepalive=60)
+
+            self.client.on_connect = self.on_connect
+            self.client.on_disconnect = self.on_disconnect
+            self.client.on_message = self.on_message
+
+            self.client.loop_start()
+
+            logger.info("Connected to broker", host=self.cfg.host, port=self.cfg.port)
+        except Exception as e:
+            logger.error("Failed to connect to broker", host=self.cfg.host, port=self.cfg.port, error=str(e))
+            raise OSError(f"Connection Failure to {self.cfg.host}:{self.cfg.port} as {self.cfg.user} -- {e}") from e
+
+    def stop(self) -> None:
+        if self.client:
+            self.client.loop_stop()
+            self.client.disconnect()
+            self.client = None
+
+    def on_connect(
+        self, _client: mqtt.Client, _userdata: Any, _flags: mqtt.ConnectFlags, rc: ReasonCode, _props: Properties | None
+    ) -> None:
+        if not self.client:
+            self.log.warn("No client, check if started")
+            return
+        self.log.info("Connected to broker", result_code=rc)
+        for topic in self.providers_by_topic:
+            self.log.info("(Re)subscribing", topic=topic)
+            self.client.subscribe(topic)
+
+    def on_disconnect(
+        self,
+        _client: mqtt.Client,
+        _userdata: Any,
+        _disconnect_flags: mqtt.DisconnectFlags,
+        rc: ReasonCode,
+        _props: Properties | None,
+    ) -> None:
+        self.log.info("Disconnected from broker", result_code=rc)
+
+    async def clean_topics(
+        self, provider: ReleaseProvider, last_scan_session: str | None, wait_time: int = 5, force: bool = False
+    ) -> None:
+        logger = self.log.bind(action="clean")
+        logger.info("Starting clean cycle")
+        cleaner = mqtt.Client(
+            callback_api_version=CallbackAPIVersion.VERSION1,
+            client_id=f"updates2mqtt_clean_{self.node_cfg.name}",
+            clean_session=True,
+        )
+        results = {"cleaned": 0, "handled": 0, "discovered": 0, "last_timestamp": time.time()}
+        cleaner.username_pw_set(self.cfg.user, password=self.cfg.password)
+        cleaner.connect(host=self.cfg.host, port=self.cfg.port, keepalive=60)
+        prefixes = [
+            f"{self.hass_cfg.discovery.prefix}/update/{self.node_cfg.name}_{provider.source_type}_",
+            f"{self.cfg.topic_root}/{self.node_cfg.name}/{provider.source_type}/",
+        ]
+
+        def cleanup(_client: mqtt.Client, _userdata: Any, msg: mqtt.MQTTMessage) -> None:
+            if msg.retain and any(msg.topic.startswith(prefix) for prefix in prefixes):
+                session = None
+                results["discovered"] += 1
+                try:
+                    payload = self.safe_json_decode(msg.payload)
+                    session = payload.get("source_session")
+                except Exception as e:
+                    log.warn(
+                        "Unable to handle payload for %s: %s",
+                        msg.topic,
+                        e,
+                        exc_info=1,
+                    )
+                results["handled"] += 1
+                results["last_timestamp"] = time.time()
+                if session is not None and last_scan_session is not None and session != last_scan_session:
+                    log.debug("Removing stale msg", topic=msg.topic, session=session)
+                    cleaner.publish(msg.topic, "", retain=True)
+                    results["cleaned"] += 1
+                elif session is None and force:
+                    log.debug("Removing untrackable msg", topic=msg.topic)
+                    cleaner.publish(msg.topic, "", retain=True)
+                    results["cleaned"] += 1
+                else:
+                    log.debug(
+                        "Retaining topic with current session: %s",
+                        msg.topic,
+                    )
+            else:
+                log.debug("Skipping clean of %s", msg.topic)
+
+        cleaner.on_message = cleanup
+        options = paho.mqtt.subscribeoptions.SubscribeOptions(noLocal=True)
+        cleaner.subscribe(f"{self.hass_cfg.discovery.prefix}/update/#", options=options)
+        cleaner.subscribe(f"{self.cfg.topic_root}/{self.node_cfg.name}/{provider.source_type}/#", options=options)
+
+        while time.time() - results["last_timestamp"] <= wait_time:
+            cleaner.loop(0.5)
+
+        log.info(
+            f"Clean completed, discovered:{results['discovered']}, handled:{results['handled']}, cleaned:{results['cleaned']}"
+        )
+
+    def safe_json_decode(self, jsonish: str | bytes | None) -> dict:
+        if jsonish is None:
+            return {}
+        try:
+            return json.loads(jsonish)
+        except Exception:
+            log.exception("JSON decode fail (%s); %s", jsonish)
+        try:
+            return json.loads(jsonish[1:-1])
+        except Exception:
+            log.exception("JSON decode fail (%s): %s", jsonish[1:-1])
+        return {}
+
+    async def execute_command(
+        self, msg: MQTTMessage | LocalMessage, on_update_start: Callable, on_update_end: Callable
+    ) -> None:
+        logger = self.log.bind(topic=msg.topic, payload=msg.payload)
+        comp_name: str | None = None
+        command: str | None = None
+        try:
+            logger.info("Execution starting")
+            source_type: str | None = None
+
+            payload: str | None = None
+            if isinstance(msg.payload, bytes):
+                payload = msg.payload.decode("utf-8")
+            elif isinstance(msg.payload, str):
+                payload = msg.payload
+            if payload and "|" in payload:
+                source_type, comp_name, command = payload.split("|")
+
+            provider: ReleaseProvider | None = self.providers_by_topic.get(msg.topic) if msg.topic else None
+            if not provider:
+                logger.warn("Unexpected provider type %s", msg.topic)
+            elif provider.source_type != source_type:
+                logger.warn("Unexpected source type %s", source_type)
+            elif command != "install" or not comp_name:
+                logger.warn("Invalid payload in command message: %s", msg.payload)
+            else:
+                logger.info(
+                    "Passing %s command to %s scanner for %s",
+                    command,
+                    source_type,
+                    comp_name,
+                )
+                updated = provider.command(comp_name, command, on_update_start, on_update_end)
+                discovery = provider.resolve(comp_name)
+                if updated and discovery:
+                    self.publish_hass_state(discovery, updated)
+                else:
+                    logger.debug("No change to republish after execution")
+            logger.info("Execution ended")
+        except Exception:
+            logger.exception("Execution failed", component=comp_name, command=command)
+
+    def local_message(self, discovery: Discovery, command: str) -> None:
+        """Simulate an incoming MQTT message for local commands"""
+        msg = LocalMessage(
+            topic=self.command_topic(discovery.provider), payload="|".join([discovery.source_type, discovery.name, command])
+        )
+        self.handle_message(msg)
+
+    def on_message(self, _client: mqtt.Client, _userdata: Any, msg: mqtt.MQTTMessage) -> None:
+        """Callback for incoming MQTT messages"""  # noqa: D401
+        if msg.topic in self.providers_by_topic:
+            self.handle_message(msg)
+        else:
+            self.log.warn("Unhandled message: %s", msg.topic)
+
+    def handle_message(self, msg: mqtt.MQTTMessage | LocalMessage) -> None:
+        def update_start(discovery: Discovery) -> None:
+            self.publish_hass_state(discovery, in_progress=True)
+
+        def update_end(discovery: Discovery) -> None:
+            self.publish_hass_state(discovery, in_progress=False)
+
+        if self.event_loop is not None:
+            asyncio.run_coroutine_threadsafe(self.execute_command(msg, update_start, update_end), self.event_loop)
+        else:
+            self.log.error("No event loop to handle message", topic=msg.topic)
+
+    def config_topic(self, discovery: Discovery) -> str:
+        prefix = self.hass_cfg.discovery.prefix
+        return f"{prefix}/update/{self.node_cfg.name}_{discovery.source_type}_{discovery.name}/update/config"
+
+    def state_topic(self, discovery: Discovery) -> str:
+        return f"{self.cfg.topic_root}/{self.node_cfg.name}/{discovery.source_type}/{discovery.name}"
+
+    def command_topic(self, provider: ReleaseProvider) -> str:
+        return f"{self.cfg.topic_root}/{self.node_cfg.name}/{provider.source_type}"
+
+    def publish_hass_state(self, discovery: Discovery, in_progress: bool = False) -> None:
+        self.log.debug("HASS State update, in progress: %s, discovery: %s", in_progress, discovery)
+        self.publish(
+            self.state_topic(discovery),
+            hass_format_state(
+                discovery,
+                self.node_cfg.name,
+                discovery.session,
+                in_progress=in_progress,
+            ),
+        )
+
+    def publish_hass_config(self, discovery: Discovery) -> None:
+        object_id = f"{discovery.source_type}_{self.node_cfg.name}_{discovery.name}"
+        command_topic: str | None = self.command_topic(discovery.provider) if discovery.can_update else None
+        self.publish(
+            self.config_topic(discovery),
+            hass_format_config(
+                discovery,
+                object_id,
+                self.node_cfg.name,
+                self.state_topic(discovery),
+                command_topic,
+                discovery.session,
+            ),
+        )
+
+    def subscribe_hass_command(self, provider: ReleaseProvider):  # noqa: ANN201
+        topic = self.command_topic(provider)
+        if topic in self.providers_by_topic or self.client is None:
+            self.log.debug("Skipping subscription", topic=topic)
+        else:
+            self.log.info("Handler subscribing", topic=topic)
+            self.providers_by_topic[topic] = provider
+            self.client.subscribe(topic)
+        return topic
+
+    def loop_once(self) -> None:
+        if self.client:
+            self.client.loop()
+
+    def publish(self, topic: str, payload: dict, qos: int = 0, retain: bool = True) -> None:
+        if self.client:
+            self.client.publish(topic, payload=json.dumps(payload), qos=qos, retain=retain)

updates2mqtt-1.3.4.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: updates2mqtt
+Version: 1.3.4
+Summary: System update and docker image notification and execution over MQTT
+Project-URL: Repository, https://github.com/rhizomatics/updates2mqtt
+Project-URL: Documentation, https://updates2mqtt.rhizomatics.org.uk
+Project-URL: Issues, https://github.com/rhizomatics/updates2mqtt/issues
+Author-email: jey burrows <jrb@rhizomatics.org.uk>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: automation,docker,home-assistant,homeassistant,mqtt,selfhosting,updates
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: docker>=7.1.0
+Requires-Dist: hishel[httpx]>=0.1.4
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: omegaconf>=2.3.0
+Requires-Dist: paho-mqtt>=2.1.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: structlog>=25.4.0
+Requires-Dist: usingversion>=0.1.2
+Description-Content-Type: text/markdown
+
+[![Rhizomatics Open Source](https://avatars.githubusercontent.com/u/162821163?s=96&v=4)](https://github.com/rhizomatics)
+
+# updates2mqtt
+
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/rhizomatics/supernotify)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/rhizomatics/updates2mqtt/main.svg)](https://results.pre-commit.ci/latest/github/rhizomatics/updates2mqtt/main)
+[![Publish Python 🐍 distribution 📦 to PyPI and TestPyPI](https://github.com/rhizomatics/updates2mqtt/actions/workflows/pypi-publish.yml/badge.svg)](https://github.com/rhizomatics/updates2mqtt/actions/workflows/pypi-publish.yml)
+[![Github Deploy](https://github.com/rhizomatics/updates2mqtt/actions/workflows/python-package.yml/badge.svg?branch=main)](https://github.com/rhizomatics/updates2mqtt/actions/workflows/python-package.yml)
+[![CodeQL](https://github.com/rhizomatics/updates2mqtt/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/rhizomatics/updates2mqtt/actions/workflows/github-code-scanning/codeql)
+[![Dependabot Updates](https://github.com/rhizomatics/updates2mqtt/actions/workflows/dependabot/dependabot-updates/badge.svg)](https://github.com/rhizomatics/updates2mqtt/actions/workflows/dependabot/dependabot-updates)
+
+## Summary
+
+Use Home Assistant to notify you of updates to Docker images for your containers and optionally perform the *pull* (or optionally *build*) and *update*.
+
+![Example Home Assistant update dialog](images/ha_update_detail.png "Home Assistant Updates")
+
+## Description
+
+updates2mqtt perioidically checks for new versions of components being available, and publishes new version info to MQTT.
+HomeAssistant auto discovery is supported, so all updates can be seen in the same place as Home Assistant's
+own components and add-ins.
+
+Currently only Docker containers are supported, either via an image registry check, or a git repo for source. The design is modular, so other update sources can be added, at least for notification. The next anticipated is **apt** for Debian based systems.
+
+Components can also be updated, either automatically or triggered via MQTT, for example by hitting the *Install*
+button in the HomeAssistant update dialog. Icons and release notes can be specified for a better HA experience.
+
+## Install
+
+updates2mqtt prefers to be run inside a Docker container.
+
+### Manual
+```
+uv sync
+uv run updates2mqtt
+```
+### Docker
+
+See `examples` directory for a working `docker-compose.yaml`.
+
+If you want to update and restart containers, then the file system paths to the location of the
+directory where the docker compose file lives must be available in the updates2mqtt container. 
+
+The example `docker-compose.yaml` mounts `/home/containers` for this purpose, so if your containers are in
+`/home/containers/app1`, `/home/containers/app2` etc, then updates2mqtt will be able to find them. Map as
+many root paths as needed.
+
+## Configuration
+
+Create file `config.yaml` in `conf` directory. If the file is not present, a default file will be generated.
+
+### Example configuration file
+
+This is a maximal config file, the minimum is no config file at all, which will generate a default config file. The only mandatory values are the MQTT user name and password, everything else can be omitted.
+
+```yaml
+
+node:
+  name: docker-host-1 # Unique name for this instance, used to name MQTT entities. Defaults to O/S hostname
+  git_repo_path: /usr/bin/git # Path to git inside container, needed only if non-default and using local docker builds
+  healthcheck:
+    enabled: true
+    interval: 300 # publish a heartbeat every 5 minutes
+    topic_template: healthcheck/{node_name}/updates2mqtt
+mqtt:
+  host: ${oc.env:MQTT_HOST}
+  user: ${oc.env:MQTT_USER}
+  password: ${oc.env:MQTT_PASS}$ # Use an environment variable for secrets
+  port: ${oc.env:MQTT_PORT}
+  topic_root: updates2mqtt
+homeassistant:
+  discovery:
+    prefix: homeassistant # Matches the default MQTT discovery prefix in Home Assistant
+    enabled: true
+  state_topic_suffix: state
+docker:
+  enabled: true
+  allow_pull: true # if true, will do a `docker pull` if an update is available
+  allow_restart: true # if true, will do a `docker-compose up` if an update is installed
+  allow_build: true # if true, will do a `docker-compose build` if a git repo is configured
+  compose_version: v2 # Controls whether to use `docker-compose` (v1) or `docker compose` (v2) command
+  default_entity_picture_url: https://www.docker.com/wp-content/uploads/2022/03/Moby-logo.png # Picture for update dialog
+  device_icon: mdi:docker # Material Design Icon to use when browsing entities in Home Assistant
+  # device_icon: mdi:train-car-container # Alternative icon if you don't like Docker branding
+  discover_metadata:
+    linuxserver.io:
+      enabled: true
+      cache_ttl: 604800 # cache metadata for 1 week
+scan_interval: 10800 # sleep interval between scan runs, in seconds
+log:
+  level: INFO
+```
+
+### Moving Secrets Out of Config
+
+Example use of environment variables, e.g. for secrets:
+
+```
+mqtt:
+    password: ${oc.env:MQTT_PASS}
+```
+### Customizing images and release notes
+
+Individual docker containers can have customized entity pictures or release notes, using env variables, for example in the `docker-compose.yaml` or in a separate `.env` file:
+
+```
+    environment:
+      - UPD2MQTT_PICTURE=https://frigate.video/images/logo.svg
+      - UPD2MQTT_RELNOTES=https://github.com/blakeblackshear/frigate/releases
+```
+
+The images will show up in the *Update* section of *Settings* menu in HomeAssistant,
+as will the release notes link. SVG icons should be used.
+
+Some popular services have the icon and release note links pre-configured, in `common_packages.yaml`,
+and packages from `linuxserver.io` can have metadata automatically discovered.
+
+#### Icon Sources
+
+- [Homarr Dashboard Icons](https://github.com/homarr-labs/dashboard-icons)
+- [Self Hosted Icons](https://github.com/selfhst/icons)
+- [Simple Icons](https://github.com/simple-icons/simple-icons)
+- [Tabler Icons](https://tabler.io/icons)
+- [Papirus Icons](https://github.com/PapirusDevelopmentTeam/papirus-icon-theme)
+- [Homelab SVG Assets](https://github.com/loganmarchione/homelab-svg-assets)
+
+### Automated updates
+
+If Docker containers should be immediately updated, without any confirmation
+or trigger, *e.g.* from the HomeAssistant update dialog, then set an environment variable `UPD2MQTT_UPDATE`
+in the target container to `Auto` ( it defaults to `Passive`)
+
+### Custom docker builds
+
+If the image is locally built from a checked out git repo, package update can be driven
+by the availability of git repo changes to pull rather than a new image on a Docker registry.
+
+Declare the git path using the env var in ``UPD2MQTT_GIT_REPO_PATH`` in the docker container ( directly or via an ``.env`` file).
+The git repo at this path will be used as the source of timestamps, and an update command will carry out a 
+``git pull`` and ``docker-compose build`` rather than pulling an image.
+
+Note that the updates2mqtt docker container needs access to this path declared in its volumes, and that has to
+be read/write if automated install required.
+
+### Environment Variables
+
+The following environment variables can be used to configure updates2mqtt:
+
+| Env Var | Description | Default  |
+|---------| ------------|----------|
+| `UPD2MQTT_UPDATE`  | Update mode, either `Passive` or `Auto`. If `Auto`, updates will be installed automatically. | `Passive` |
+| `UPD2MQTT_PICTURE`  | URL to an icon to use in Home Assistant.  | Docker logo URL   |
+| `UPD2MQTT_RELNOTES` | URL to release notes for the package.  |  | 
+| `UPD2MQTT_GIT_REPO_PATH` | Relative path to a local git repo if the image is built locally.  | |
+| `UPD2MQTT_IGNORE` | If set to `True`, the container will be ignored by updates2mqtt. | False |
+
+
+## Release Support
+
+| Ecosystem | Support     | Comments                                                                                           |
+|-----------|-------------|----------------------------------------------------------------------------------------------------|
+| Docker    | Scan. Fetch | Fetch is ``docker pull`` only. Restart support only for ``docker-compose`` image based containers. |
+  
+## Healthcheck
+
+A heartbeat JSON payload is optionally published periodically to a configurable MQTT topic, defaulting to `healthcheck/{node_name}/updates2mqtt`. It contains the current version of updates2mqtt, the node name, a timestamp, and some basic stats.
+
+A `healthcheck.sh` script is included in the Docker image, and can be used as a Docker healthcheck, if the container environment variables are set for `MQTT_HOST`, `MQTT_PORT`, `MQTT_USER` and `MQTT_PASS`.
+
+TIP: Check healthcheck is working using `docker inspect --format "{{json .State.Health }}" updates2mqtt | jq`
+  
+## HomeAssistant integration
+
+Any updates that have support for automated install will automatically show in the
+Home Assistant settings page if the [MQTT Integration](https://www.home-assistant.io/integrations/mqtt/) is installed and automatic discovery is not disabled.
+
+![Home Assistant MQTT Integraion configuration](images/ha_mqtt_discovery.png "Home Assistant MQTT Discovery")
+
+The `homeassistant` default topic prefix matches the default updates2mqtt config, if its changed in HomeAssistant, then the updates2mqtt config must be changed to match.
+
+![Home Assistant updates in Settings](images/ha_update_page.png "Home Assistant Updates")
+
+For Home Assistant integration, updates2mqtt represents each component being managed as a [MQTT Update](https://www.home-assistant.io/integrations/update.mqtt/) entity, and uses [MQTT discovery(https://www.home-assistant.io/integrations/mqtt/#mqtt-discovery)] so that HomeAssistant automatically picks up components discovered by updates2mqtt with zero configuration on HomeAssistant itself. 
+
+There are 3 separate types of MQTT topic used for HomeAssisstant integration:
+
+- *Config* to support auto discovery. A topic is created per component, with a name like `homeassistant/update/dockernuc_docker_jellyfin/update/config`. This can be disabled in the config file, and the `homeassistant` topic prefix can also be configured.
+- *State* to report the current version and the latest version available, again one topic per component, like `updates2mqtt/dockernuc/docker/jellyfin`.
+- *Command* to support triggering an update. These will be created on the fly by HomeAssistant when an update is requested, and updates2mqtt subscribes to pick up the changes, so you won't typically see these if browsing MQTT topics. Only one is needed per updates2mqtt agent, with a name like `updates2mqtt/dockernuc/docker`
+
+If the package supports automated update, then *Skip* and *Install* buttons will appear on the Home Assistant
+interface, and the package can be remotely fetched and the component restarted.
+
+## Related Projects
+
+- [psmqtt](https://github.com/eschava/psmqtt) - Report system health and metrics via MQTT
+- 
+## Development
+
+Access to Docker APIs uses the Python [docker-py](https://docker-py.readthedocs.io/en/stable/) SDK for Python. [Eclipse Paho](https://eclipse.dev/paho/files/paho.mqtt.python/html/client.html) is used for MQTT access, and [OmegaConf](https://omegaconf.readthedocs.io) for configuration.

updates2mqtt-1.3.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+updates2mqtt/__init__.py,sha256=gnmHrLOSYc-N1-c5VG46OpNpoXEybKzYhEvFMm955P8,237
+updates2mqtt/__main__.py,sha256=HBF00oH5fhS33sI_CdbxNlaUvbIzuuGxwnRYdhHqx0M,194
+updates2mqtt/app.py,sha256=dfoqIIFq0kAm0KHjtEF_RrNC9-fJBQ7Y2_8suwWBOJU,7738
+updates2mqtt/config.py,sha256=TIybHWpGAPLA1uWsZt0miwzboX1AlCNHoGO_JoGMlBo,4270
+updates2mqtt/hass_formatter.py,sha256=Ulfj8F0e_1QMmRuJzHsNM2WxHbz9sIkWOWjRq3kQZzs,2772
+updates2mqtt/model.py,sha256=5tWlj3appGGZjkuBeYR2lb-kXoy5mzCn4P_EJQjnwok,3676
+updates2mqtt/mqtt.py,sha256=kDpbq9jk0av6FqyZrSPtg5oQrbklI0BMMH8wxnAp0OI,12230
+updates2mqtt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+updates2mqtt/integrations/__init__.py,sha256=KmNTUxvVWvqI7rl4I0xZg7XaCmcMS2O4OSv-ClsWM4Q,109
+updates2mqtt/integrations/docker.py,sha256=OX_sXtWVgUJfRSFi_tTBib4gvP_foQI4MoeTkTeLbZc,18868
+updates2mqtt/integrations/git_utils.py,sha256=SkAp6XcvCHwaiy17t6F97kcWTjBd7RyEmfhz6M_EhP0,2196
+updates2mqtt-1.3.4.dist-info/METADATA,sha256=K96yWjB_b3rp5ErGl__gefFWvcvLSMGMMmDmNlTKQ8I,12781
+updates2mqtt-1.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+updates2mqtt-1.3.4.dist-info/entry_points.txt,sha256=Hc6NZ2dBevYSUKTJU6NOs8Mw7Vt0S-9lq5FuKb76NCc,54
+updates2mqtt-1.3.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+updates2mqtt-1.3.4.dist-info/RECORD,,

updates2mqtt-1.3.4.dist-info/WHEEL

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

updates2mqtt-1.3.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+updates2mqtt = updates2mqtt.app:run