uiprotect 0.1.0__py3-none-any.whl

uiprotect/websocket.py

@@ -0,0 +1,225 @@
+"""UniFi Protect Websockets."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from collections.abc import Callable, Coroutine
+from typing import Any, Optional
+
+from aiohttp import (
+    ClientError,
+    ClientSession,
+    ClientWebSocketResponse,
+    WSMessage,
+    WSMsgType,
+)
+
+from .utils import asyncio_timeout
+
+_LOGGER = logging.getLogger(__name__)
+CALLBACK_TYPE = Callable[..., Coroutine[Any, Any, Optional[dict[str, str]]]]
+RECENT_FAILURE_CUT_OFF = 30
+RECENT_FAILURE_THRESHOLD = 2
+
+
+class Websocket:
+    """UniFi Protect Websocket manager."""
+
+    url: str
+    verify: bool
+    timeout_interval: int
+    backoff: int
+    _auth: CALLBACK_TYPE
+    _timeout: float
+    _ws_subscriptions: list[Callable[[WSMessage], None]]
+    _connect_lock: asyncio.Lock
+
+    _headers: dict[str, str] | None = None
+    _websocket_loop_task: asyncio.Task[None] | None = None
+    _timer_task: asyncio.Task[None] | None = None
+    _ws_connection: ClientWebSocketResponse | None = None
+    _last_connect: float = -1000
+    _recent_failures: int = 0
+
+    def __init__(
+        self,
+        url: str,
+        auth_callback: CALLBACK_TYPE,
+        *,
+        timeout: int = 30,
+        backoff: int = 10,
+        verify: bool = True,
+    ) -> None:
+        """Init Websocket."""
+        self.url = url
+        self.timeout_interval = timeout
+        self.backoff = backoff
+        self.verify = verify
+        self._auth = auth_callback
+        self._timeout = time.monotonic()
+        self._ws_subscriptions = []
+        self._connect_lock = asyncio.Lock()
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if Websocket connected."""
+        return self._ws_connection is not None
+
+    def _get_session(self) -> ClientSession:
+        # for testing, to make easier to mock
+        return ClientSession()
+
+    def _process_message(self, msg: WSMessage) -> bool:
+        if msg.type == WSMsgType.ERROR:
+            _LOGGER.exception("Error from Websocket: %s", msg.data)
+            return False
+
+        for sub in self._ws_subscriptions:
+            try:
+                sub(msg)
+            except Exception:
+                _LOGGER.exception("Error processing websocket message")
+
+        return True
+
+    async def _websocket_loop(self, start_event: asyncio.Event) -> None:
+        _LOGGER.debug("Connecting WS to %s", self.url)
+        self._headers = await self._auth(self._should_reset_auth)
+
+        session = self._get_session()
+        # catch any and all errors for Websocket so we can clean up correctly
+        try:
+            self._ws_connection = await session.ws_connect(
+                self.url,
+                ssl=None if self.verify else False,
+                headers=self._headers,
+            )
+            start_event.set()
+
+            self._reset_timeout()
+            async for msg in self._ws_connection:
+                if not self._process_message(msg):
+                    break
+                self._reset_timeout()
+        except ClientError:
+            _LOGGER.exception("Websocket disconnect error: %s")
+        finally:
+            _LOGGER.debug("Websocket disconnected")
+            self._increase_failure()
+            self._cancel_timeout()
+            if self._ws_connection is not None and not self._ws_connection.closed:
+                await self._ws_connection.close()
+            if not session.closed:
+                await session.close()
+            self._ws_connection = None
+            # make sure event does not timeout
+            start_event.set()
+
+    @property
+    def has_recent_connect(self) -> bool:
+        """Check if Websocket has recent connection."""
+        return time.monotonic() - RECENT_FAILURE_CUT_OFF <= self._last_connect
+
+    @property
+    def _should_reset_auth(self) -> bool:
+        if self.has_recent_connect:
+            if self._recent_failures > RECENT_FAILURE_THRESHOLD:
+                return True
+        else:
+            self._recent_failures = 0
+        return False
+
+    def _increase_failure(self) -> None:
+        if self.has_recent_connect:
+            self._recent_failures += 1
+        else:
+            self._recent_failures = 1
+
+    async def _do_timeout(self) -> bool:
+        _LOGGER.debug("WS timed out")
+        return await self.reconnect()
+
+    async def _timeout_loop(self) -> None:
+        while True:
+            now = time.monotonic()
+            if now > self._timeout:
+                _LOGGER.debug("WS timed out")
+                if not await self.reconnect():
+                    _LOGGER.debug("WS could not reconnect")
+                    continue
+            sleep_time = self._timeout - now
+            _LOGGER.debug("WS Timeout loop sleep %s", sleep_time)
+            await asyncio.sleep(sleep_time)
+
+    def _reset_timeout(self) -> None:
+        self._timeout = time.monotonic() + self.timeout_interval
+
+        if self._timer_task is None:
+            self._timer_task = asyncio.create_task(self._timeout_loop())
+
+    def _cancel_timeout(self) -> None:
+        if self._timer_task:
+            self._timer_task.cancel()
+
+    async def connect(self) -> bool:
+        """Connect the websocket."""
+        if self._connect_lock.locked():
+            _LOGGER.debug("Another connect is already happening")
+            return False
+        try:
+            async with asyncio_timeout(0.1):
+                await self._connect_lock.acquire()
+        except (TimeoutError, asyncio.TimeoutError, asyncio.CancelledError):
+            _LOGGER.debug("Failed to get connection lock")
+
+        start_event = asyncio.Event()
+        _LOGGER.debug("Scheduling WS connect...")
+        self._websocket_loop_task = asyncio.create_task(
+            self._websocket_loop(start_event),
+        )
+
+        try:
+            async with asyncio_timeout(self.timeout_interval):
+                await start_event.wait()
+        except (TimeoutError, asyncio.TimeoutError, asyncio.CancelledError):
+            _LOGGER.warning("Timed out while waiting for Websocket to connect")
+            await self.disconnect()
+
+        self._connect_lock.release()
+        if self._ws_connection is None:
+            _LOGGER.debug("Failed to connect to Websocket")
+            return False
+        _LOGGER.debug("Connected to Websocket successfully")
+        self._last_connect = time.monotonic()
+        return True
+
+    async def disconnect(self) -> None:
+        """Disconnect the websocket."""
+        _LOGGER.debug("Disconnecting websocket...")
+        if self._ws_connection is None:
+            return
+        await self._ws_connection.close()
+        self._ws_connection = None
+
+    async def reconnect(self) -> bool:
+        """Reconnect the websocket."""
+        _LOGGER.debug("Reconnecting websocket...")
+        await self.disconnect()
+        await asyncio.sleep(self.backoff)
+        return await self.connect()
+
+    def subscribe(self, ws_callback: Callable[[WSMessage], None]) -> Callable[[], None]:
+        """
+        Subscribe to raw websocket messages.
+
+        Returns a callback that will unsubscribe.
+        """
+
+        def _unsub_ws_callback() -> None:
+            self._ws_subscriptions.remove(ws_callback)
+
+        _LOGGER.debug("Adding subscription: %s", ws_callback)
+        self._ws_subscriptions.append(ws_callback)
+        return _unsub_ws_callback

uiprotect-0.1.0.dist-info/LICENSE

@@ -0,0 +1,23 @@
+
+MIT License
+
+Copyright (c) 2024 UI Protect Maintainers
+Copyright (c) 2020 Bjarne Riis
+
+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.

uiprotect-0.1.0.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.1
+Name: uiprotect
+Version: 0.1.0
+Summary: Python API for Unifi Protect (Unofficial)
+Home-page: https://github.com/uilibs/uiprotect
+License: MIT
+Author: UI Protect Maintainers
+Author-email: ui@koston.org
+Requires-Python: >=3.10
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: aiofiles (>=23)
+Requires-Dist: aiohttp (>=3.9.0)
+Requires-Dist: aioshutil (>=1.3)
+Requires-Dist: async-timeout (>=3.0.1)
+Requires-Dist: dateparser (>=1.1.0)
+Requires-Dist: orjson (>=3.9)
+Requires-Dist: packaging (>=23)
+Requires-Dist: pillow (>=10)
+Requires-Dist: platformdirs (>=4)
+Requires-Dist: pydantic (!=1.9.1)
+Requires-Dist: pyjwt (>=2.6)
+Requires-Dist: rich (>=10)
+Requires-Dist: typer[all] (>0.6)
+Requires-Dist: yarl (>=1.9)
+Project-URL: Bug Tracker, https://github.com/uilibs/uiprotect/issues
+Project-URL: Changelog, https://github.com/uilibs/uiprotect/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://uiprotect.readthedocs.io
+Project-URL: Repository, https://github.com/uilibs/uiprotect
+Description-Content-Type: text/markdown
+
+# Unofficial UniFi Protect Python API and CLI
+
+<p align="center">
+  <a href="https://github.com/uilibs/uiprotect/actions/workflows/ci.yml?query=branch%3Amain">
+    <img src="https://img.shields.io/github/actions/workflow/status/uilibs/uiprotect/ci.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
+  </a>
+  <a href="https://uiprotect.readthedocs.io">
+    <img src="https://img.shields.io/readthedocs/uiprotect.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
+  </a>
+  <a href="https://codecov.io/gh/uilibs/uiprotect">
+    <img src="https://img.shields.io/codecov/c/github/uilibs/uiprotect.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
+  </a>
+</p>
+<p align="center">
+  <a href="https://python-poetry.org/">
+    <img src="https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json" alt="Poetry">
+  </a>
+  <a href="https://github.com/astral-sh/ruff">
+    <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff">
+  </a>
+  <a href="https://github.com/pre-commit/pre-commit">
+    <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
+  </a>
+</p>
+<p align="center">
+  <a href="https://pypi.org/project/uiprotect/">
+    <img src="https://img.shields.io/pypi/v/uiprotect.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/uiprotect.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
+  <img src="https://img.shields.io/pypi/l/uiprotect.svg?style=flat-square" alt="License">
+</p>
+
+---
+
+**Documentation**: <a href="https://uiprotect.readthedocs.io" target="_blank">https://uiprotect.readthedocs.io </a>
+
+**Source Code**: <a href="https://github.com/uilibs/uiprotect" target="_blank">https://github.com/uilibs/uiprotect </a>
+
+---
+
+Python API for Unifi Protect (Unofficial)
+
+## Installation
+
+Install this via pip (or your favorite package manager):
+
+`pip install uiprotect`
+
+## Credits
+
+- Bjarne Riis ([@briis](https://github.com/briis/)) for the original pyunifiprotect package
+- Christopher Bailey ([@AngellusMortis](https://github.com/AngellusMortis/)) for the maintaining the pyunifiprotect package
+
+## Contributors ✨
+
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- prettier-ignore-start -->
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- markdownlint-disable -->
+<!-- markdownlint-enable -->
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+<!-- prettier-ignore-end -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
+
+`uiprotect` is an unofficial API for UniFi Protect. There is no affiliation with Ubiquiti.
+
+This module communicates with UniFi Protect surveillance software installed on a UniFi OS Console such as a Ubiquiti CloudKey+ or UniFi Dream Machine Pro.
+
+The API is not documented by Ubiquiti, so there might be misses and/or frequent changes in this module, as Ubiquiti evolves the software.
+
+The module is primarily written for the purpose of being used in Home Assistant core [integration for UniFi Protect](https://www.home-assistant.io/integrations/unifiprotect) but might be used for other purposes also.
+
+## Smart Detections now Require Remote Access to enable
+
+Smart Detections (person, vehicle, animal, face), a feature that previously could be used with local only console, [now requires you to enable remote access to enable](https://community.ui.com/questions/Cannot-enable-Smart-Detections/e3d50641-5c00-4607-9723-453cda557e35#answer/1d146426-89aa-4022-a0ae-fd5000846028).
+
+Enabling Remote Access may grant other users access to your console [due to the fact Ubiquiti can reconfigure access controls at any time](https://community.ui.com/questions/Bug-Fix-Cloud-Access-Misconfiguration/fe8d4479-e187-4471-bf95-b2799183ceb7).
+
+If you are not okay with the feature being locked behind Remote Access access, [let Ubiquiti know](https://community.ui.com/questions/Cannot-enable-Smart-Detections/e3d50641-5c00-4607-9723-453cda557e35).
+
+## Documentation
+
+[Full documentation for the project](https://uilibs.github.io/uiprotect/).
+
+## Requirements
+
+If you want to install `uiprotect` natively, the below are the requirements:
+
+- [UniFi Protect](https://ui.com/camera-security) version 1.20+
+  - Latest version of library is generally only tested against the two latest minor version. This is either two latest stable versions (such as 1.21.x and 2.0.x) or the latest EA version and stable version (such as 2.2.x EA and 2.1.x).
+- [Python](https://www.python.org/) 3.9+
+- POSIX compatible system
+  - Library is only test on Linux, specifically the latest Debian version available for the official Python Docker images, but there is no reason the library should not work on any Linux distro or MacOS.
+- [ffmpeg](https://ffmpeg.org/)
+  - ffmpeg is primarily only for streaming audio to Protect cameras, this can be considered a soft requirement
+
+Alternatively you can use the [provided Docker container](#using-docker-container), in which case the only requirement is [Docker](https://docs.docker.com/desktop/) or another OCI compatible orchestrator (such as Kubernetes or podman).
+
+Windows is **not supported**. If you need to use `uiprotect` on Windows, use Docker Desktop and the provided docker container or [WSL](https://docs.microsoft.com/en-us/windows/wsl/install).
+
+## Install
+
+### From PyPi
+
+`uiprotect` is available on PyPi:
+
+```bash
+pip install uiprotect
+```
+
+### From Github
+
+```bash
+pip install git+https://github.com/uilibs/uiprotect.git#egg=uiprotect
+```
+
+### Using Docker Container
+
+A Docker container is also provided so you do not need to install/manage Python as well. You can add the following to your `.bashrc` or similar.
+
+```bash
+function unifi-protect() {
+    docker run --rm -it \
+      -e UFP_USERNAME=YOUR_USERNAME_HERE \
+      -e UFP_PASSWORD=YOUR_PASSWORD_HERE \
+      -e UFP_ADDRESS=YOUR_IP_ADDRESS \
+      -e UFP_PORT=443 \
+      -e UFP_SSL_VERIFY=True \
+      -e TZ=America/New_York \
+      -v $PWD:/data ghcr.io/uilibs/uiprotect:latest "$@"
+}
+```
+
+Some notes about the Docker version since it is running inside of a container:
+
+- You can update at any time using the command `docker pull ghcr.io/uilibs/uiprotect:latest`
+- Your local current working directory (`$PWD`) will automatically be mounted to `/data` inside of the container. For commands that output files, this is the _only_ path you can write to and have the file persist.
+- The container supports `linux/amd64` and `linux/arm64` natively. This means it will also work well on MacOS or Windows using Docker Desktop.
+- `TZ` should be the [Olson timezone name](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) for the timezone your UniFi Protect instance is in.
+- For more details on `TZ` and other environment variables, check the [command line docs](https://uilibs.github.io/uiprotect/latest/cli/)
+
+## Quickstart
+
+### CLI
+
+!!! warning "About Ubiquiti SSO accounts"
+Ubiquiti SSO accounts are not supported and actively discouraged from being used. There is no option to use MFA. You are expected to use local access user. `uiprotect` is not designed to allow you to use your owner account to access the your console or to be used over the public Internet as both pose a security risk.
+
+```bash
+export UFP_USERNAME=YOUR_USERNAME_HERE
+export UFP_PASSWORD=YOUR_PASSWORD_HERE
+export UFP_ADDRESS=YOUR_IP_ADDRESS
+export UFP_PORT=443
+# change to false if you do not have a valid HTTPS Certificate for your instance
+export UFP_SSL_VERIFY=True
+
+unifi-protect --help
+unifi-protect nvr
+```
+
+### Python
+
+UniFi Protect itself is 100% async, so as such this library is primarily designed to be used in an async context.
+
+The main interface for the library is the `uiprotect.ProtectApiClient`:
+
+```python
+from uiprotect import ProtectApiClient
+
+protect = ProtectApiClient(host, port, username, password, verify_ssl=True)
+
+await protect.update() # this will initialize the protect .bootstrap and open a Websocket connection for updates
+
+# get names of your cameras
+for camera in protect.bootstrap.cameras.values():
+    print(camera.name)
+
+# subscribe to Websocket for updates to UFP
+def callback(msg: WSSubscriptionMessage):
+    # do stuff
+
+unsub = protect.subscribe_websocket(callback)
+
+# remove subscription
+unsub()
+
+```
+
+## TODO / Planned / Not Implemented
+
+Generally any feature missing from the library is planned to be done eventually / nice to have with the following exceptions
+
+### UniFi OS Features
+
+Anything that is strictly a UniFi OS feature. If it ever done, it will be in a separate library that interacts with this one. Examples include:
+
+- Managing RAID and disks
+- Creating and managing users
+
+Examples include:
+
+- Stream sharing
+- Smart Detections, including person, vehicle, animals license plate and faces
+

uiprotect-0.1.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+uiprotect/__init__.py,sha256=tzcxK6cOIIkFEtST4Zjq3bafYTFWtwnaL92DgypjFi8,307
+uiprotect/__main__.py,sha256=T69KE5W4zek6qeNEL8_Fq2DEfBc04SqSuIOJpiW4ydE,471
+uiprotect/api.py,sha256=mmAmPBs0Zev_2KWLO_l5QU8pFOsFzuYt-OZMvfV3mq0,65694
+uiprotect/cli/__init__.py,sha256=tmwtYrhM8rjOw8noKD6NALl_2Nu3xIycDuQyEKD5oMk,8832
+uiprotect/cli/backup.py,sha256=Mtjd2f0w7zjIeLkJILKxiBnZJYXypzC9gpyAmBZ8sq0,36746
+uiprotect/cli/base.py,sha256=8EqGb7tJulq_IHGrZuRtevfpX7l08Hc6yizBU1snZp8,7627
+uiprotect/cli/cameras.py,sha256=mVLJ5FjZPSbpNXvtd7Yiz17zMDSdLWT0p6Wcaqpt0GQ,16996
+uiprotect/cli/chimes.py,sha256=92kNiZN7FpuCF7CqK9oLPt2jQ96tNhTjP1JcOdJAKhU,5350
+uiprotect/cli/doorlocks.py,sha256=XMftrrK0O0bWZHOuTwg9m4p9U7gC0FzHFb72bSnlUEg,3547
+uiprotect/cli/events.py,sha256=Ni_igTOdOf11pklpNEocBdwd3EW6O0wD8Iz-lN2zMJA,7225
+uiprotect/cli/lights.py,sha256=EgJsQ37c3QzSKoYf6h-rCaQoiftNh2igY1bTB_tQz14,3338
+uiprotect/cli/liveviews.py,sha256=TrLAqG2_GpNoWyw9IRY-4mJmlFwxGZxUuIdi-YU_NuM,1887
+uiprotect/cli/nvr.py,sha256=PVpUitWzP9HLy2yoj0HP-b-4Te5AFCrahUAmrQJ4z-w,4276
+uiprotect/cli/sensors.py,sha256=CE77weDkYepo9eEs1J0ModIs3pWNWmesjAq3rlmiez0,8177
+uiprotect/cli/viewers.py,sha256=SZlolZH3kkcWKjATrA37TCVZYRpF0t4cCccrC8vIv-M,2195
+uiprotect/data/__init__.py,sha256=38Kb1DVi4kv9FTTwugatPNSWLiIp6uvUlTMZRQp2jTY,3050
+uiprotect/data/base.py,sha256=k65F05OHN2l-nlQ5bVeXxTSYvvGj7pZz_jfe2KmWOSk,37423
+uiprotect/data/bootstrap.py,sha256=d3SmJa4SJkosNc_Ve_ySPnRxtIfxXdioTmAoczuz3YQ,21738
+uiprotect/data/convert.py,sha256=f8QkwZnlNbV_W-YognlDvZ1gQKp5yFuC50396hcu6DU,2127
+uiprotect/data/devices.py,sha256=RMucQXXAyN6VwLvFZwsxauStwXZkdQGUITSZ9h_iQXY,112765
+uiprotect/data/nvr.py,sha256=Sr1lxmmtmQm6wje-UwY0i18cGUys8f8kvJmlFhapst4,47485
+uiprotect/data/types.py,sha256=5eLL2jBl1eHiMwxbL6l0qngsmhg1F0dBrAS5GtDVdgg,15427
+uiprotect/data/user.py,sha256=c-rslssNHhHOYplPE5lGGfuDexvI0mVYhbb6Xyi5dgo,7022
+uiprotect/data/websocket.py,sha256=HKAze9b9soOS03_2zixRTR7jlFIA4ph9wMZEo15q6NY,6107
+uiprotect/exceptions.py,sha256=kgn0cRM6lTtgLza09SDa3ZiX6ue1QqHCOogQ4qu6KTQ,965
+uiprotect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uiprotect/release_cache.json,sha256=NamnSFy78hOWY0DPO87J9ELFCAN6NnVquv8gQO75ZG4,386
+uiprotect/stream.py,sha256=V4aJfVWpSUsWE1PQrXH8F7obQQi1ukPAZ7PzwABjt0I,4942
+uiprotect/test_util/__init__.py,sha256=sSEXu6_pwdYNQSCYtftpX1Dy1S8XYOvhrpECYRxeKJE,18596
+uiprotect/test_util/anonymize.py,sha256=AGYELhDC4BrdK0deI6zh5jFp3SuM_HvAWLeoxFHSiwg,8486
+uiprotect/utils.py,sha256=evW60TmyccHPsifBUukqiXGd0QHnYibqaJhvowIDh-M,17841
+uiprotect/websocket.py,sha256=iMTdchymaCgVHsmY1bRbxkcymqt6WQircIHYNxCu178,7289
+uiprotect-0.1.0.dist-info/LICENSE,sha256=INx18jhdbVXMEiiBANeKEbrbz57ckgzxk5uutmmcxGk,1111
+uiprotect-0.1.0.dist-info/METADATA,sha256=aPwnx0VBKI4VScd1F65pHzKYWgo5He1GdIK8Cgzbbwk,10588
+uiprotect-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+uiprotect-0.1.0.dist-info/entry_points.txt,sha256=J78AUTPrTTxgI3s7SVgrmGqDP7piX2wuuEORzhDdVRA,47
+uiprotect-0.1.0.dist-info/RECORD,,

uiprotect-0.1.0.dist-info/WHEEL

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

uiprotect-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+uiprotect=uiprotect.cli:app
+