py-app-runner 0.5.49.dev0__py3-none-any.whl

py_app_runner/wbcm/wb_connection_manager.py

@@ -0,0 +1,333 @@
+import asyncio
+import logging
+import threading
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from database_wrapper_redis import RedisDbAsync
+
+from py_app_runner.registry import AppRegistry
+from py_app_runner.tick_service import TickService
+from py_app_runner.utils import json_decode
+from py_app_runner.wbcm.device_connections import DeviceConnections
+from py_app_runner.wbcm.factory import UserConnections
+
+
+class WbConnectionManager:
+    logger: logging.Logger
+    tick_service: TickService
+
+    cache_db: RedisDbAsync
+    user_connections: UserConnections
+    device_connections: DeviceConnections
+
+    # Plain XREAD position (not a consumer group): every manager instance reads the
+    # full stream, so forked workers each deliver to their own sockets. "$" = only
+    # messages arriving after startup; missed history is useless to dead sockets.
+    stream_last_id: str = "$"
+
+    shutdown_lock: threading.Lock
+
+    def __init__(self, cache_db: RedisDbAsync, debug: bool = False) -> None:
+        assert cache_db is not None, "cache_db is required"
+
+        loggerName = f"{__name__}.{self.__class__.__name__}"
+        self.logger = logging.getLogger(loggerName)
+        self.tick_service = TickService(1, self.tick, self.shutdown)
+
+        self.cache_db = cache_db
+        self.user_connections = UserConnections()
+        self.device_connections = DeviceConnections()
+        self.stream_last_id = "$"
+
+        self.shutdown_lock = threading.Lock()
+
+        debug_level = logging.DEBUG if debug else logging.INFO
+        self.logger.setLevel(debug_level)
+        self.tick_service.logger.setLevel(debug_level)
+        self.tick_service.timer.logger.setLevel(debug_level)
+
+    def __del__(self) -> None:
+        self.logger.debug("Deleting WbConnectionManager")
+
+    ####################
+    ### Process loop ###
+    ####################
+
+    def start_in_new_loop(self) -> None:
+        self.logger.debug("Starting WbConnectionManager in a new loop")
+        self.tick_service.skip_signal_handling = True
+
+        try:
+            asyncio.run(self.start())
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            ...  # Ignore this exception
+
+    async def start(self):
+        self.logger.info("Starting")
+        await self.tick_service.run_loop()
+
+    async def stop(self):
+        self.logger.info("Stopping")
+        await self.tick_service.stop_loop()
+
+    async def shutdown(self):
+        self.logger.debug("Stop the event loop")
+
+        # We run on the manager's background thread; the sockets belong to the web
+        # server's loop. Closing them directly is not thread safe, and iterating the
+        # live dict would break as on_close() removes entries from it.
+        for _conn_id, conn in list(self.user_connections.items()):
+            try:
+                conn.loop.call_soon_threadsafe(conn.close)
+            except Exception:
+                pass
+
+        for _conn_id, conn in list(self.device_connections.items()):
+            try:
+                conn.loop.call_soon_threadsafe(conn.close)
+            except Exception:
+                pass
+
+        self.user_connections.reset()
+        self.device_connections.reset()
+
+    async def tick(self, tick_count: int, tick_time: float):
+        try:
+            async with self.connect_dbs():
+                with self.tick_service.timer.enter("Get data"):
+                    await self.process_messages()
+
+        except Exception as e:
+            self.logger.exception(f"Unknown error: {e}")
+
+    #############
+    ### Utils ###
+    #############
+
+    @asynccontextmanager
+    async def connect_dbs(self) -> AsyncGenerator[bool]:
+        try:
+            self.logger.debug("Opening DB connections")
+            await self.cache_db.open()
+
+            yield True
+
+        finally:
+            self.logger.debug("Closing DB connections")
+            await self.cache_db.close()
+
+    async def read_stream_data(self, stream_name: str) -> Any:
+        self.logger.debug(f"Reading stream data after {self.stream_last_id}")
+        return await self.cache_db.connection.xread(
+            streams={stream_name: self.stream_last_id},
+            count=500,
+            block=2000,
+        )
+
+    def send_message(
+        self,
+        user_id: str,
+        message: bytes | str | dict[str, Any] | list[Any],
+        source_uid: str,
+    ) -> None:
+        connections = self.user_connections.get_connections_by_user_id(user_id)
+        if not connections:
+            self.logger.debug(f"No connections for user {user_id}")
+            return
+
+        self.logger.debug(f"Sending message to {user_id}")
+        for conn in connections:
+            # Skip the source connection
+            if conn.uid == source_uid:
+                self.logger.debug(f"Skipping source connection {source_uid}")
+                continue
+
+            try:
+                self.logger.debug(f"Sending message to {conn.uid} for user {user_id}")
+                conn.loop.call_soon_threadsafe(
+                    conn.write_custom_message,
+                    message,
+                    False,
+                )
+            except Exception as e:
+                self.logger.warning(f"Removing connection {conn.uid} for exception {e}")
+                self.user_connections.remove_connection(conn)
+                continue
+
+    def send_message_to_device(
+        self,
+        device_id: str,
+        message: bytes | str | dict[str, Any] | list[Any],
+        source_uid: str,
+    ) -> None:
+        connections = self.device_connections.get_connections_by_device_id(device_id)
+        if not connections:
+            self.logger.debug("No connections for device %s", device_id)
+            return
+
+        self.logger.debug("Sending message to device %s", device_id)
+        for conn in connections:
+            if conn.uid == source_uid:
+                continue
+            try:
+                conn.loop.call_soon_threadsafe(
+                    conn.write_custom_message,
+                    message,
+                    False,
+                )
+            except Exception as e:
+                self.logger.warning("Removing device connection %s for exception %s", conn.uid, e)
+                self.device_connections.remove_connection(conn)
+                continue
+
+    def close_sessions(
+        self,
+        user_id: str,
+        source_uid: str,
+        target_sid: str | None = None,
+    ) -> None:
+        """Hard-close revoked live sockets.
+
+        Closing (not just notifying) is what makes a revoke enforceable: a client
+        that ignores a notification must not keep an authenticated socket. With
+        `target_sid` only that one session's socket is closed; otherwise all of
+        the user's sockets except `source_uid`."""
+
+        connections = self.user_connections.get_connections_by_user_id(user_id)
+        for conn in connections:
+            if conn.uid == source_uid:
+                continue
+            if target_sid is not None and conn.current_session_sid != target_sid:
+                continue
+
+            try:
+                self.logger.debug(f"Closing connection {conn.uid} for user {user_id}")
+                conn.loop.call_soon_threadsafe(conn.close)
+            except Exception as e:
+                self.logger.warning(f"Failed to close connection {conn.uid}: {e}")
+
+    def send_message_to_all(
+        self,
+        message: bytes | str | dict[str, Any] | list[Any],
+        source_uid: str,
+    ) -> None:
+        self.logger.debug("Sending message to all")
+        # Snapshot: the loop below removes dead connections from the same dict.
+        for _user_id, conn in list(self.user_connections.items()):
+            # Skip the source connection
+            if conn.uid == source_uid:
+                self.logger.debug(f"Skipping source connection {source_uid}")
+                continue
+
+            try:
+                self.logger.debug(f"Sending message to {conn.uid}")
+                conn.loop.call_soon_threadsafe(
+                    conn.write_custom_message,
+                    message,
+                    False,
+                )
+            except Exception as e:
+                self.logger.warning(f"Removing connection {conn.uid} for exception {e}")
+                self.user_connections.remove_connection(conn)
+                continue
+
+    ########################
+    ### Process messages ###
+    ########################
+
+    async def process_messages(self) -> None:
+        self.logger.debug("Find new messages in the stream")
+        stream_name = AppRegistry.redis_channel()
+        cached_data = await self.read_stream_data(stream_name)
+        if not cached_data or stream_name not in cached_data or not cached_data[stream_name][0]:
+            self.logger.debug("No records found")
+            return
+
+        items_found_count: int = 0
+        message_data = cached_data[stream_name][0]
+
+        self.logger.info(f"Processing {len(message_data)} records")
+        for message_id, msg_data in message_data:
+            # A raising message must never hold up the stream position, otherwise the
+            # same batch is re-read on every tick forever.
+            try:
+                if self.work(msg_data):
+                    items_found_count += 1
+            except Exception:
+                self.logger.exception(f"Failed to process message {message_id!r}, skipping it")
+
+            self.stream_last_id = message_id
+
+        self.logger.info(f"Processed {items_found_count} messages")
+
+    def work(self, message_data: dict[str, Any]) -> bool:
+        self.logger.debug(f"Processing message {message_data}")
+
+        if "service" not in message_data:
+            self.logger.error(f"Message data does not contain service: {message_data!r}")
+            return False
+
+        if "type" not in message_data:
+            self.logger.error(f"Message data does not contain type: {message_data!r}")
+            return False
+
+        if "data" not in message_data:
+            self.logger.error(f"Message data does not contain data: {message_data!r}")
+            return False
+
+        if "source_uid" not in message_data:
+            self.logger.error(f"Message data does not contain source_uid: {message_data!r}")
+            return False
+
+        source_uid: str = message_data.get("source_uid", "")
+        data = message_data.get("data", None)
+        if data is not None and isinstance(data, str):
+            try:
+                message_data["data"] = json_decode(data)
+            except Exception:
+                self.logger.exception(f"Message data is not valid JSON, dropping: {message_data!r}")
+                return False
+
+        msg_type: str = message_data.get("type", "")
+
+        # Session revocation closes sockets instead of forwarding a payload.
+        if msg_type == "session_revoked":
+            user_id = message_data.get("user_id", None)
+            if user_id is None:
+                self.logger.error(f"session_revoked without user_id: {message_data!r}")
+                return False
+
+            self.close_sessions(
+                user_id,
+                source_uid,
+                message_data.get("target_sid", None) or None,
+            )
+            return True
+
+        # Session relay: route to device or user based on target_type
+        if msg_type == "session_relay":
+            target_type = message_data.get("target_type", "")
+            target_id = message_data.get("target_id", "")
+            if target_type == "device":
+                self.send_message_to_device(target_id, message_data, source_uid)
+            elif target_type == "user":
+                self.send_message(target_id, message_data, source_uid)
+            else:
+                self.logger.error("session_relay with unknown target_type: %s", target_type)
+                return False
+            return True
+
+        # Default behavior: route by user_id
+        if "user_id" not in message_data:
+            self.logger.error(f"Message data does not contain user_id: {message_data!r}")
+            return False
+
+        user_id: str | None = message_data.get("user_id", None)
+        if user_id is None:
+            self.send_message_to_all(message_data, source_uid)
+        else:
+            self.send_message(user_id, message_data, source_uid)
+
+        return True

py_app_runner/wbcm/ws_interface.py

@@ -0,0 +1,56 @@
+from abc import ABC, abstractmethod
+from asyncio import AbstractEventLoop, Future
+from typing import Any
+
+
+class WebSocketHandlerInterface(ABC):
+    uid: str | None
+    msg_id: int | None
+    service: str | None
+    current_session_sid: str | None
+
+    loop: AbstractEventLoop
+
+    @abstractmethod
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.uid = None
+        self.msg_id = None
+        self.service = None
+        self.current_session_sid = None
+
+    @abstractmethod
+    def error_message(self, msg: str, code: int = -1, **kwargs: Any) -> None:
+        pass
+
+    @abstractmethod
+    def write_custom_message(
+        self,
+        message: bytes | str | dict[str, Any] | list[Any],
+        wrap_in_data: bool = True,
+        **kwargs: Any,
+    ) -> Future[None]:
+        pass
+
+    @abstractmethod
+    def check_origin(self, origin: str) -> bool:
+        pass
+
+    @abstractmethod
+    async def open(self, *args: str, **kwargs: str) -> None:
+        pass
+
+    @abstractmethod
+    def ping(self, data: str | bytes = b"") -> None:
+        pass
+
+    @abstractmethod
+    async def on_message(self, message: str | bytes) -> None:
+        pass
+
+    @abstractmethod
+    def close(self, code: int | None = None, reason: str | None = None) -> None:
+        pass
+
+    @abstractmethod
+    def on_close(self) -> None:
+        pass

py_app_runner-0.5.49.dev0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: py_app_runner
+Version: 0.5.49.dev0
+Summary: Async service framework: Tornado HTTP/WS bridge, service loader, Redis WS connection manager
+Author-email: Gints Murans <gm@gm.lv>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/4Apps/py_app_runner
+Project-URL: Documentation, https://github.com/4Apps/py_app_runner/blob/master/AGENTS.md
+Project-URL: Code, https://github.com/4Apps/py_app_runner
+Project-URL: Issue Tracker, https://github.com/4Apps/py_app_runner/issues
+Project-URL: Download, https://pypi.org/project/py-app-runner/
+Keywords: async,tornado,websocket,framework,service,redis,postgresql,migrations,queue
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sentry-sdk
+Requires-Dist: python-dotenv
+Requires-Dist: uvloop
+Requires-Dist: msgspec
+Requires-Dist: msgpack
+Requires-Dist: tornado
+Requires-Dist: database_wrapper[pgsql,redis]==0.3.146
+Requires-Dist: psycopg>=3.2.0
+Requires-Dist: psycopg[pool]>=3.2.0
+Requires-Dist: redis
+Requires-Dist: pyjwt
+Requires-Dist: cryptography>=44
+Requires-Dist: bcrypt
+Provides-Extra: dev
+Requires-Dist: pyrefly; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
+
+# py_app_runner
+
+Async Python service framework: Tornado HTTP/WS bridge, PyBridge service loader, Redis WebSocket connection manager.
+
+## Install
+
+```bash
+pip install py_app_runner
+```
+
+Every push to `develop` publishes a pre-release, `X.Y.<commit count>.dev0`. pip hides those
+unless you ask for them:
+
+```bash
+pip install --pre py_app_runner        # newest, including dev builds
+pip install py_app_runner==0.4.50.dev0 # a specific dev build
+```
+
+## Development
+
+```bash
+docker-compose up develop
+```
+
+## Migrations
+
+Built-in service that applies tracked SQL files to one or more configured databases. Add
+`migrations` to `SERVICES` to enable it.
+
+```bash
+python3 src/app.py migrations status   [--check] [--target NAME]
+python3 src/app.py migrations apply    [--dry-run] [--to PREFIX] [--target NAME]
+python3 src/app.py migrations baseline [--to PREFIX] [--yes] [--target NAME]
+python3 src/app.py migrations new      <name> [--target NAME]
+python3 src/app.py migrations repair   <filename> [--target NAME]
+```
+
+By default there is a single target, `main`, against `config["db"]["main"]`: files live in
+`config["migrations"]["dir"]` (default `data/migrations`) and are tracked in
+`config["migrations"]["table"]` (default `migrations`). **No project needs to change
+anything to keep this working** - an absent `migrations` key, an empty one, and this flat
+shape all resolve to that same single target.
+
+To migrate more than one database, opt in with `config["migrations"]["targets"]`:
+
+```python
+"migrations": {
+    "targets": {
+        "main": {"db": "main", "dir": "data/migrations", "table": "migrations"},
+        "gis": {"db": "gis", "dir": "data/migrations_gis", "table": "gis_migrations"},
+    }
+}
+```
+
+Each target's `db` names a key under `config["db"]` and defaults to the target's own name;
+`dir` and `table` default as above. `status` and `apply` with no `--target` run every
+target in declared order (`apply` stops at the first one that fails; `status --check`
+reports each target rather than stopping at the first with pending work, and exits 1 if any
+is pending or blocked). `new`, `repair` and `baseline` require `--target` once more than one
+target is configured, and an unknown `--target` exits 1 - both name the configured targets.
+Output gets a `[name] ` prefix only when more than one target is processed, so single-target
+output is unchanged.
+
+Targets may share a database, but not a database *and* a tracking table - each would then
+report the other's migrations as missing, so that config is refused up front, naming both
+targets. `table` defaults to `migrations` for every target, so two targets on one database
+need an explicit `table` on at least one of them.
+
+- Migrations no longer need to be idempotent - each file runs in its own transaction with
+  its tracking row written inside it, so what already ran is always known.
+- `-- migrations:no-transaction` on line 1 runs a file outside a transaction (for
+  `CREATE INDEX CONCURRENTLY` and friends). Such a file must contain **exactly one
+  statement**: Postgres wraps a multi-statement send in an implicit transaction, which would
+  defeat the directive, so `apply` refuses it up front. A no-transaction file that fails
+  cannot roll back and is not recorded - `apply` says so and tells you to inspect the
+  database before re-running.
+- Editing an applied file is detected as drift, and a tracked file that has since been
+  deleted shows as missing; both block `apply` until resolved. `repair` fixes drift only;
+  a missing file is fixed by restoring it, or by deleting its tracking row by hand
+  (`apply` prints the exact `DELETE` when it blocks).
+- Files must not contain psql meta-commands (`\restrict` / `\unrestrict`, as emitted by
+  `pg_dump`) - psycopg cannot execute them, and `apply` refuses such a file up front.
+- `baseline` adopts an existing database into the system: it writes tracking rows without
+  executing anything.
+- Every subcommand exits non-zero on failure, including a misconfigured `targets` block.
+  `status --check` exits 1 if anything is pending, drifted or missing, so a deploy script
+  can halt before restarting services against a half-migrated database.

py_app_runner-0.5.49.dev0.dist-info/RECORD

@@ -0,0 +1,75 @@
+py_app_runner/__init__.py,sha256=-06k2fPyJBVR2E23A54_ip7-C7Lv0L_YCjkTvk67qg8,310
+py_app_runner/colors.py,sha256=fwgl_PHeMAryyu6saydHOK7SYF_bqmWG5BiEgDcmYHs,2162
+py_app_runner/config.py,sha256=G5ZMY-RVhdB0mnwmjoogLdnsTqoQ-xTnG_tAFj3q-9Y,4057
+py_app_runner/db_pools.py,sha256=yk8OkfLFZ5-BvU_pWgfr-fCKTMDS4UYTy1fDOm8ZP0g,546
+py_app_runner/http_exception.py,sha256=Kpjmk54HYNC2PZH9RIYuiQSTJar1qYp35LR6jT44q2k,767
+py_app_runner/logger_handlers.py,sha256=Pd45xLPbhEEYgqlHg2il76NX0CyXd1y4rtV_jmNA6-c,4937
+py_app_runner/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_app_runner/pybridge.py,sha256=1MwazLm9oeXMYcrjB0J4DwH7w-edPguIM8F6LNHJGGc,2541
+py_app_runner/registry.py,sha256=P6QCg5ivyr_S9JO0W3Tv7xO5n_OEmaUV2ffCNn3Ckno,1531
+py_app_runner/return_model.py,sha256=9V8iCuFvtskSR-MT3qh0oGjZENmtIDe55hJAEw_b3Ac,1680
+py_app_runner/runner.py,sha256=GCwpuChgHQHcG3B0Ss3PXqlW58BC9uNIV7AbO4Y9ZDQ,5596
+py_app_runner/tick_service.py,sha256=wqEA8cU9mCu3KOgCpk5_LmkSJifZG1ewlNabLodeHH0,11010
+py_app_runner/timer.py,sha256=8kXMvLA--NPhhzHR53BiIwol6ts4YRq7ywr6DyKz-cQ,9155
+py_app_runner/utils.py,sha256=qOzTNAyrlRhn_4gb_-Go0GtxwWkLkn0WsplQwaKb6N0,10139
+py_app_runner/audit/__init__.py,sha256=2idlte6sD9rf5QZGGqKJN0_BrJ4_kxe_wlX8CIgjE7s,582
+py_app_runner/audit/_service.py,sha256=qKGOBEx2PL3DwJv9PKNOKZ81L-oUycCk_2dJmdxwM3U,3341
+py_app_runner/audit/_service_args.py,sha256=Wv_2CGXrSjZd4JRCLpibjHpY60LZZ9xAL9k9sHIfHcM,1898
+py_app_runner/audit/audit.py,sha256=xgShwmCTW28DDPvZAO-0e-aFcV0k4FKN0azTP4Qypgs,11725
+py_app_runner/audit/commands.py,sha256=z8ApHQSDVMQGT5vH7jYjio75Q4yNbjsCYrUvva0BoB8,4449
+py_app_runner/audit/diff.py,sha256=VDY4SVP1Acnkdb_C5LEpkDGdiXH85SahaelDPAgzhpY,6893
+py_app_runner/audit/errors.py,sha256=bej4Jqapd0vb_rBEjZwCCvE-5_5nfRApiBzGcSxCizI,369
+py_app_runner/audit/event.py,sha256=vJXDA13wqLf-73WzDLYT7xRL5msFXEGBnxq2KL_BzDU,3994
+py_app_runner/audit/store.py,sha256=NriBE9mTA9hnxQ5uvsNiOqA79uCImyxk2eJ-Ueshkoc,4277
+py_app_runner/bridge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_app_runner/bridge/_service.py,sha256=-NNYqDpsff8p7tFbXf0DNNhQXTwQkziHxKl3T8ajIno,9684
+py_app_runner/bridge/_service_args.py,sha256=P0pLcaPXPiPjDTWhj1YCzwHzbQJBz7K0zFMjgHqVy9g,828
+py_app_runner/bridge/api.py,sha256=lepe1wfAR7GfI_XfL2sCAg3ah1hh7YbUvxfIcdK_wYM,5489
+py_app_runner/bridge/web_app.py,sha256=XOMKMCBvJRwX5wirMYLI_sHkeYKVilqBJ3vcObbIICo,1261
+py_app_runner/bridge/websocket.py,sha256=NaMeC3X5RnbxWqgEOW__4IRVDxUFc2Um6dmHXCojqDw,11779
+py_app_runner/bridge/encoders/__init__.py,sha256=F4pe2wNdkgUaPEraDOEjOIdUtIkiavQPngYKsrlyn9A,178
+py_app_runner/bridge/encoders/base.py,sha256=LsGwu5_v09ZATY3c8jRY9_eLt_u-bP1tBwBMbhoHkFs,724
+py_app_runner/bridge/encoders/json_encoder.py,sha256=apYWHO_z5TtBBdyE-fQlI0B91iMPuGdSCh5gXdsfHi8,612
+py_app_runner/bridge/encoders/msgpack_encoder.py,sha256=nLojvRDJeHgbANTu3imCYpHaISlknFICPPZAPWCsOG4,1492
+py_app_runner/crypto/__init__.py,sha256=d25Dza7wGNIMFi2-W0dKKMeBvFsrk37kLsSVgIO5cd0,408
+py_app_runner/crypto/_service.py,sha256=G0MOKmPpfibUuhPfhuCqxXnZDPhEs0tIO1Rp_mM1_Ag,2988
+py_app_runner/crypto/_service_args.py,sha256=397lCCyYhWfPgA_ZMAq4yQSc_wEJw6f3JEkmDU6AYy0,1952
+py_app_runner/crypto/commands.py,sha256=iha0_ftmqdYe-yM_0D-K1TsXiCT1WkQzSKXqpayrvGg,5561
+py_app_runner/crypto/envelope.py,sha256=8amdymB8SpSuyNyB8klGmx38IPwJd2GgnsRJLVvAAyQ,5572
+py_app_runner/crypto/errors.py,sha256=8kukvUKqB4-pybylg9qAaUkBoLPahmhFxQKktP_1LhI,457
+py_app_runner/crypto/fields.py,sha256=QcWBLaJdvseR0nlgcbWHt4HhU1D9-atiNLQZEYPguIg,11137
+py_app_runner/crypto/passwords.py,sha256=R4sxYzDlIb7jWiE1FBqd8VX30FRlI0nX5ZAq0inif-g,2550
+py_app_runner/migrations/__init__.py,sha256=EtB9skFtbRWpYCTOzBwf39Bx_iUXVT4bdqFdLHGALv8,173
+py_app_runner/migrations/_service.py,sha256=SiV-PispLQSCNaGuLhpdGk_LIFYyHZK8ZuBUkxzthhQ,13361
+py_app_runner/migrations/_service_args.py,sha256=LusJM-jh9F0SdmWohYYzzrG2So8bbT3z7YVONr1imfM,3412
+py_app_runner/migrations/commands.py,sha256=_myCf5Xb8hth_GYxO4UhBcY-L9-WixNNKQkdzWQYiRE,14302
+py_app_runner/migrations/discovery.py,sha256=L3cXuNa_P7-8tKSAaAd412weoiwCLgInT28y0y1Ry_c,3686
+py_app_runner/migrations/states.py,sha256=2t7WV4jQhunp3WMCfdqBZQqNsh1F5iJWYtbZ3-ngbLU,1741
+py_app_runner/migrations/tracker.py,sha256=sW34evKuMTyIOtr8xGn0BQQ6t967a7kquf9O3Q39GM0,5704
+py_app_runner/queue/__init__.py,sha256=2iL8thHW0Sz8XAHx3eMBkSAytVXErMpt5-xykxULq80,766
+py_app_runner/queue/_service.py,sha256=E885H0713Btc0q1NgfkO-_ZX9E5hcPzCZoFBJTK53Nc,8373
+py_app_runner/queue/_service_args.py,sha256=ZEhFdtKZdo8Yvla1Uiw_HsBJLCJ5YBduv7SX9QBRL1w,3244
+py_app_runner/queue/commands.py,sha256=pD3HWIS4G6ERIYgbWH5QqmIAd7tIi4t7WqL7V2IRjUo,5405
+py_app_runner/queue/driver_pg.py,sha256=nTMAmTl5izMHtEKUqBwh8vHLnIbNXcIS__lJzww-3Ws,18448
+py_app_runner/queue/driver_redis.py,sha256=n3RLDOsrr9lRJYbu3Qw412yJuf17BAt4Msdi1j_nKoE,21705
+py_app_runner/queue/handler.py,sha256=IrCvER7rkAc-SDv_BvGo2bWvbeteOqX2FeAjqauCekw,3386
+py_app_runner/queue/interface.py,sha256=rm4KmGl3E-eJOcN1cy_LN6Eh3CIxkeIH0REB8AE6GfA,2253
+py_app_runner/queue/job.py,sha256=bSAYQ03DuV_qeuB7U69s8Vqa8IwI4sulL_nhQMuAm50,1522
+py_app_runner/queue/worker.py,sha256=suvz_KJxDPsK_G7O1iPa0GcexMGCM-oPOKGUrEnVYoc,8040
+py_app_runner/request_handler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_app_runner/request_handler/auth_service.py,sha256=0sT9yx-d_umee-drEZrZaEIA8Bo1PJejGzA9tdKW_g8,3968
+py_app_runner/request_handler/decorators.py,sha256=hzHCUla1jmbvmOVHxGv6n9EG2v7fcnQ17zScsSkMOHk,11916
+py_app_runner/request_handler/handlers.py,sha256=PYy7ShoOQiYlCccRDozVFdLFFHBZcZo8vBkzPdLOrgQ,20555
+py_app_runner/request_handler/pagination.py,sha256=kwTIESjGBNVUTw_WMO5hQmX2wslOjtPduTEee5YEnr0,655
+py_app_runner/throttle/__init__.py,sha256=Nro3YzxTNurUXjijicF06_B8oI_jYLB2zeWBl4lpX24,141
+py_app_runner/throttle/throttle.py,sha256=slIBhi5Nn8_UlQDX5v_t3PGdlwpPJbMW8lD16WrRoO0,8273
+py_app_runner/wbcm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_app_runner/wbcm/device_connections.py,sha256=GvHzqBGGpgoWuGVnkMzWKrxbWKVxzd-VGG9XUIcI0Vk,3288
+py_app_runner/wbcm/factory.py,sha256=4lLIuVGFgvY8g0gYQShitN9kRXAJJPDpMExuSbJugoU,4046
+py_app_runner/wbcm/wb_connection_manager.py,sha256=TAwyXA8FNywWK2DTkcx-zsT6RfFWQs9iccf4YnS1VSw,12315
+py_app_runner/wbcm/ws_interface.py,sha256=HiULD518DuUnF0xvdL5roTQsVzJQEoHOlz1gN7s7zTE,1348
+py_app_runner-0.5.49.dev0.dist-info/licenses/LICENSE,sha256=NClrlP01PpaS6SoxF7FRZQOIFOZoefTsJoW0Y9MzOKs,1080
+py_app_runner-0.5.49.dev0.dist-info/METADATA,sha256=VnIWMNe3jTk9y2G_zZKYrY-bZah5zcRF9q_q01twuJo,6058
+py_app_runner-0.5.49.dev0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+py_app_runner-0.5.49.dev0.dist-info/top_level.txt,sha256=-HU5naBcGqnM2P9ovTpBouINvi6MPL-vi_72PJzrWQw,14
+py_app_runner-0.5.49.dev0.dist-info/RECORD,,

py_app_runner-0.5.49.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py_app_runner-0.5.49.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Gints Murāns
+
+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.

py_app_runner-0.5.49.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+py_app_runner