py-bragerone 0.2.4__py3-none-any.whl

bragerone/__init__.py

@@ -0,0 +1,11 @@
+# src/bragerone/__init__.py
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("py-bragerone")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+from .gateway import Gateway
+
+__all__ = ["Gateway", "__version__"]

bragerone/__main__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+import argparse
+import asyncio
+import logging
+from .gateway import Gateway
+
+def setup_logging(level: str):
+    lvl = getattr(logging, level.upper(), logging.INFO)
+    logging.basicConfig(
+        level=lvl,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+    )
+
+async def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--email", required=True)
+    p.add_argument("--password", required=True)
+    p.add_argument("--object-id", type=int, required=True)
+    p.add_argument("--lang", default="en")
+    p.add_argument("--log-level", default="INFO")
+    args = p.parse_args()
+
+    setup_logging(args.log_level)
+    log = logging.getLogger("bragerone")
+
+    g = Gateway(args.email, args.password, object_id=args.object_id, lang=args.lang)
+    try:
+        await g.login()
+        await g.pick_modules()
+        await g.bootstrap_labels()
+        await g.initial_snapshot()
+        await g.start_ws()
+        while True:
+            await asyncio.sleep(3600)
+    finally:
+        await g.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())

bragerone/api.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+import json
+import aiohttp
+from typing import Any, Optional
+
+from .const import API_BASE, AUTH_URL, ORIGIN, REFERER
+
+DEFAULT_TIMEOUT = aiohttp.ClientTimeout(total=25)
+
+class Api:
+    def __init__(self, session: Optional[aiohttp.ClientSession] = None):
+        self.http = session
+        self._own = False
+        self.jwt: Optional[str] = None
+
+    async def ensure(self):
+        if self.http is None:
+            self.http = aiohttp.ClientSession()
+            self._own = True
+
+    async def close(self):
+        if self._own and self.http:
+            await self.http.close()
+
+    async def _req(self, method: str, url: str, *, headers: dict | None = None, **kw) -> Any:
+        await self.ensure()
+        headers = headers or {}
+        headers.setdefault("Accept", "application/json, text/plain, */*")
+        headers.setdefault("Origin", ORIGIN)
+        headers.setdefault("Referer", REFERER)
+        if self.jwt:
+            headers["Authorization"] = f"Bearer {self.jwt}"
+        kw.setdefault("timeout", DEFAULT_TIMEOUT)
+        async with self.http.request(method, url, headers=headers, **kw) as r:
+            txt = await r.text()
+            ct = r.headers.get("content-type", "")
+            if r.status >= 400:
+                raise RuntimeError(f"{method} {url} -> {r.status}: {txt[:400]}")
+            if "application/json" in ct or txt.startswith(("{","[")):
+                try:
+                    return json.loads(txt)
+                except json.JSONDecodeError:
+                    return txt
+            return txt
+
+    # ---------- high-level ----------
+    async def login(self, email: str, password: str) -> dict:
+        data = await self._req("POST", AUTH_URL, json={"email": email, "password": password})
+        tok = data.get("accessToken") if isinstance(data, dict) else None
+        if not tok:
+            raise RuntimeError("Brak accessToken w odpowiedzi logowania")
+        self.jwt = tok
+        return data
+
+    async def list_objects(self) -> list[dict]:
+        objs: list[dict] = []
+        try:
+            d = await self._req("GET", f"{API_BASE}/objects")
+            items = d.get("data") or d.get("items") or d.get("objects") or d
+            if isinstance(items, list):
+                for it in items:
+                    oid = it.get("id") or it.get("group_id") or it.get("object_id")
+                    name = it.get("name") or it.get("title") or it.get("label") or f"Object {oid}"
+                    if oid is not None:
+                        objs.append({"id": int(oid), "name": name})
+        except Exception:
+            pass
+        if not objs:
+            try:
+                u = await self._req("GET", f"{API_BASE}/user")
+                cand = u.get("objects") or u.get("groups") or u.get("data", {}).get("groups") or []
+                for it in cand:
+                    oid = it.get("id") or it.get("group_id")
+                    name = it.get("name") or it.get("title") or it.get("label") or f"Object {oid}"
+                    if oid is not None:
+                        objs.append({"id": int(oid), "name": name})
+            except Exception:
+                pass
+        return list({o["id"]: o for o in objs}.values())
+
+    async def list_modules(self, object_id: int) -> list[dict]:
+        d = await self._req("GET", f"{API_BASE}/modules?page=1&limit=999&group_id={object_id}")
+        items = d.get("data") or d.get("items") or d.get("modules") or d
+        return items if isinstance(items, list) else []
+
+    async def snapshot_parameters(self, devs: list[str]) -> dict:
+        res = await self._req("POST", f"{API_BASE}/modules/parameters", json={"modules": devs})
+        return res if isinstance(res, dict) else {}
+
+    async def activity_quantity(self, devs: list[str]) -> dict:
+        res = await self._req("POST", f"{API_BASE}/modules/activity/quantity", json={"modules": devs})
+        return res if isinstance(res, dict) else {}
+
+    async def modules_connect(self, wsid: str, devs: list[str], object_id: int | None = None) -> bool:
+        headers = {
+            "X-Requested-With": "XMLHttpRequest",
+            "Content-Type": "application/json;charset=UTF-8",
+        }
+        payloads = [
+            {"wsid": wsid, "modules": devs},
+            {"sid": wsid, "modules": devs},
+            {"wsid": wsid, "group_id": object_id, "modules": devs} if object_id else None,
+        ]
+        for pl in payloads:
+            if not pl: continue
+            try:
+                res = await self._req("POST", f"{API_BASE}/modules/connect", json=pl, headers=headers)
+                if isinstance(res, dict):
+                    return True
+            except Exception:
+                continue
+        return False
+

bragerone/const.py

@@ -0,0 +1,14 @@
+IO_BASE  = "https://io.brager.pl"         # API + login + WS
+ONE_BASE = "https://one.brager.pl"        # assety frontendu
+API_BASE = f"{IO_BASE}/v1"
+
+# HTTP dekoracja (dla assetów/frontu)
+ORIGIN  = ONE_BASE
+REFERER = f"{ONE_BASE}/"
+
+# WS / Socket.IO
+WS_NAMESPACE = "/ws"
+SOCK_PATH    = "/socket.io"
+
+# Endpoints
+AUTH_URL = f"{API_BASE}/auth/user"

bragerone/gateway.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Dict, Optional
+
+from .const import IO_BASE, ONE_BASE, API_BASE, WS_NAMESPACE
+from .api import Api
+from .labels import LabelFetcher
+from .ws import WsClient
+
+
+class Gateway:
+    """
+    Spina Api (REST), LabelFetcher (etykiety z frontendowych assetów) i WsClient (socket.io).
+    Utrzymuje prosty stan ostatnich wartości i robi czytelne logi zmian.
+    """
+
+    def __init__(self, email: str, password: str, object_id: int, lang: str = "en"):
+        self.email = email
+        self.password = password
+        self.object_id = object_id
+        self.lang = lang
+
+        self.log = logging.getLogger("BragerOne")
+        self.api = Api()
+        self.labels = LabelFetcher(base_url=ONE_BASE, http_get=self._http_get)
+        self.ws = WsClient(self.api, logger=self.log.getChild("ws"))
+
+        self.jwt: Optional[str] = None
+        self.devids: list[str] = []
+        self._state: Dict[str, Any] = {}  # np. {"P6.v0": 65}
+
+        # CB z WS
+        self.ws.add_event_cb(self._on_ws_event)
+        self.ws.add_change_cb(self._on_ws_change)
+
+    # -------- helpers --------
+
+    async def _http_get(self, url: str) -> str:
+        # delegat dla LabelFetcher-a
+        return await self.api._req("GET", url)
+
+    def _pretty_name(self, pool: str, var: str) -> str:
+        # stosujemy aliasy z LabelFetcher, jeśli są; inaczej proste pool.var
+        label = self.labels.param_label(pool, var, self.lang)
+        if label:
+            return f"{pool}.{var} [{label}]"
+        # druga próba: label po numerze (vNN -> NN)
+        try:
+            if var and var[0].isalpha():
+                num = int(var[1:])
+            else:
+                num = None
+        except Exception:
+            num = None
+        if num is not None:
+            lbl2 = self.labels.param_label(pool, num, self.lang)
+            if lbl2:
+                return f"{pool}.{var} [{lbl2}]"
+        return f"{pool}.{var}"
+
+    # -------- public flow --------
+
+    async def login(self) -> None:
+        await self.api.ensure()
+        await self.api.login(self.email, self.password)
+        self.jwt = self.api.jwt
+        self.log.info("Login OK")
+
+    async def pick_modules(self) -> None:
+        mods = await self.api.list_modules(self.object_id)
+        devids = [m.get("devid") or m.get("device_id") or m.get("id") for m in mods if m]
+        self.devids = [d for d in devids if d]
+        if not self.devids:
+            raise RuntimeError("No modules for that object_id")
+        self.log.info("Modules: %s", self.devids)
+
+    async def bootstrap_labels(self) -> None:
+        try:
+            await self.labels.bootstrap(lang=self.lang)
+            self.log.debug("[labels] bootstrap ok")
+        except Exception as e:
+            self.log.warning("[labels] bootstrap failed: %s", e)
+
+    async def initial_snapshot(self) -> None:
+        snap = await self.api.snapshot_parameters(self.devids)
+        # flatten + log
+        cnt = 0
+        for _dev, pools in (snap or {}).items():
+            if not isinstance(pools, dict):
+                continue
+            for pool, vars_ in (pools or {}).items():
+                if not isinstance(vars_, dict):
+                    continue
+                for var, meta in (vars_ or {}).items():
+                    if not isinstance(meta, dict):
+                        continue
+                    val = meta.get("value")
+                    key = f"{pool}.{var}"
+                    self._state[key] = val
+                    self.log.info("[init] %s = %s", self._pretty_name(pool, var), val)
+                    cnt += 1
+        self.log.debug("[init] snapshot items: %d", cnt)
+
+    async def start_ws(self) -> None:
+        """
+        Proxy dla kompatybilności z __main__.py.
+        Łączy WS, wiąże sesję z modułem i subskrybuje zmiany parametrów.
+        """
+        if not self.jwt:
+            raise RuntimeError("JWT is empty – call login() first")
+
+        # 1) uruchom websocket (autoryzacja tokenem)
+        await self.ws.start_ws(self.jwt, namespace=WS_NAMESPACE)
+        self.log.info("WS connected %s", WS_NAMESPACE)
+
+        # 2) powiązanie sesji WS z modułami przez REST
+        sid = self.ws.get_sid()
+        ok = await self.api.modules_connect(sid, self.devids, object_id=self.object_id)
+        self.log.info("modules.connect: %s", ok)
+
+        # 3) subskrypcje (to co wcześniej działało)
+        await self.ws.subscribe(self.devids, namespace=WS_NAMESPACE)
+
+    async def connect_ws(self) -> None:
+        if not self.jwt:
+            raise RuntimeError("JWT missing; call login() first")
+
+        await self.ws.start_ws(self.jwt, namespace=WS_NAMESPACE)
+
+        # powiązanie sesji WS z modułem przez REST (to jest endpoint HTTP)
+        try:
+            ok = await self.api.modules_connect(self.ws.sio.sid, self.devids, object_id=self.object_id)
+            self.log.info("modules.connect: %s", ok)
+        except Exception as e:
+            self.log.warning("modules.connect failed: %s", e)
+
+        # subskrypcje
+        await self.ws.subscribe(self.devids, namespace=WS_NAMESPACE)
+
+    async def run_full_flow(self) -> None:
+        """
+        Używane przez CLI: login -> modules -> labels -> snapshot -> WS -> wait.
+        """
+        await self.login()
+        await self.pick_modules()
+        await self.bootstrap_labels()
+        await self.initial_snapshot()
+        await self.connect_ws()
+        await self.ws.wait_forever()
+
+    async def close(self) -> None:
+        await self.ws.close()
+        await self.api.close()
+
+    # -------- WS callbacks --------
+
+    def _on_ws_event(self, name: str, data: Any) -> None:
+        # lekki log przydatny w debug
+        try:
+            if isinstance(data, (dict, list)):
+                self.log.debug("[ws %s] %s", name, json.dumps(data, ensure_ascii=False))
+            else:
+                self.log.debug("[ws %s] %r", name, data)
+        except Exception:
+            self.log.debug("[ws %s] %r", name, data)
+
+    def _on_ws_change(self, payload: dict) -> None:
+        # payload: {"<devid>":{"P6":{"v0":{"value":65}}}}
+        try:
+            for _devid, pools in (payload or {}).items():
+                if not isinstance(pools, dict):
+                    continue
+                for pool, vars_ in pools.items():
+                    if not isinstance(vars_, dict):
+                        continue
+                    for var, meta in vars_.items():
+                        new_val = meta.get("value") if isinstance(meta, dict) else meta
+                        key = f"{pool}.{var}"
+                        old_val = self._state.get(key)
+                        if new_val != old_val:
+                            self._state[key] = new_val
+                            self.log.info("[change] %s: %s -> %s",
+                                          self._pretty_name(pool, var), old_val, new_val)
+        except Exception as e:
+            self.log.debug("on_change parse error: %s | raw=%s", e, payload)
+

bragerone/labels.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+import logging
+from typing import Callable, Dict, Optional
+
+from .const import ONE_BASE
+
+HttpGet = Callable[[str], "str | bytes"]
+
+# NOTE: simple safe fallback resolver; parser WIP
+POOL_NAMES_PL = {
+    "P4":  "Sensors",
+    "P5":  "Statuses",
+    "P6":  "Boiler settings",
+    "P7":  "P7",
+    "P8":  "Login/Passwords",
+    "P10": "Burner settings",
+    "P11": "Hardware/Software",
+    "P12": "Thermostats",
+    "P17": "P17",
+}
+
+class LabelFetcher:
+    def __init__(self, base_url: str = ONE_BASE, http_get: Optional[HttpGet] = None, logger: Optional[logging.Logger] = None):
+        self.base_url = base_url.rstrip("/")
+        self.http_get = http_get
+        self.log = logger or logging.getLogger("bragerone.labels")
+
+        # alias maps: "parameters.PARAM_7" -> {"pl":"Temperatura załączenia pomp", ...}
+        self._alias_lang_map: Dict[str, Dict[str, str]] = {}
+        # reverse map: ("P6", 7) -> "parameters.PARAM_7"
+        self._param_alias: Dict[tuple[str, int], str] = {}
+
+    # --- public API ---
+    async def bootstrap(self, lang: str = "en"):
+        """
+        In the future: fetch index bundle(s), parse `parameters-*.js` assets, etc.
+        For now: keep it no-op but safe, so logging works and nothing crashes.
+        """
+        # No-op parser (WIP). Keep your earlier dumps for the next step.
+        return
+
+    def count_vars(self) -> int:
+        return len(self._param_alias)
+
+    def count_langs(self) -> int:
+        # count unique languages across all aliases
+        langs = set()
+        for d in self._alias_lang_map.values():
+            langs.update(d.keys())
+        return len(langs)
+
+    def param_label(self, pool: str, num: int, lang: str = "en") -> Optional[str]:
+        """
+        Return human-readable label for (pool, num); if not known, fall back to None.
+        """
+        alias = self._param_alias.get((pool, num))
+        if alias:
+            tr = self._alias_lang_map.get(alias, {})
+            # try requested lang
+            if lang in tr and tr[lang]:
+                return tr[lang]
+            # try English
+            if "en" in tr and tr["en"]:
+                return tr["en"]
+            # try Polish
+            if "pl" in tr and tr["pl"]:
+                return tr["pl"]
+        return None
+
+    def pool_human(self, pool: str, lang: str = "en") -> str:
+        # simple fallback pool names
+        return POOL_NAMES_PL.get(pool, pool)
+
+    # --- helpers for Gateway ---
+    def pretty(self, pool: str, var: str, lang: str = "en") -> str:
+        num = None
+        if var and var[:1] in ("v", "u", "s", "n", "x"):
+            try:
+                num = int(var[1:])
+            except Exception:
+                pass
+        if num is not None:
+            label = self.param_label(pool, num, lang)
+            if label:
+                return f"[{self.pool_human(pool, lang)}] {pool}.{var} – {label}"
+            return f"[{self.pool_human(pool, lang)}] {pool}.{var}"
+        return f"{pool}.{var}"
+

bragerone/ws.py

@@ -0,0 +1,120 @@
+# ws.py
+from __future__ import annotations
+import socketio
+from typing import Any, Callable, Optional
+
+from .const import IO_BASE, ONE_BASE, WS_NAMESPACE
+
+SOCK_PATH = "/socket.io"
+
+class WsClient:
+    def __init__(self, api, logger=None):
+        self.api = api
+        self.log = logger
+        self.sio: Optional[socketio.AsyncClient] = None
+        self._ws_sid: Optional[str] = None
+        self._ns: str = WS_NAMESPACE
+        self._on_event: list[Callable[[str, Any], None]] = []
+        self._on_change: list[Callable[[dict], None]] = []
+
+    # --- kompatybilność: używa tego Gateway ---
+    @property
+    def wsid(self) -> Optional[str]:
+        return self.get_sid()
+
+    def get_sid(self) -> Optional[str]:
+        if self._ws_sid:
+            return self._ws_sid
+        if self.sio:
+            try:
+                sid_ns = self.sio.get_sid(self._ns)
+            except Exception:
+                sid_ns = None
+            return sid_ns or getattr(self.sio, "sid", None)
+        return None
+
+    # --- callbacki opcjonalne (jeśli ich używasz gdzie indziej) ---
+    def add_event_cb(self, cb): self._on_event.append(cb)
+    def add_change_cb(self, cb): self._on_change.append(cb)
+
+    def _emit_event(self, name: str, data: Any):
+        for cb in list(self._on_event):
+            try: cb(name, data)
+            except Exception: pass
+
+    def _emit_change(self, payload: dict):
+        for cb in list(self._on_change):
+            try: cb(payload)
+            except Exception: pass
+
+    def _wire_handlers(self, namespace: str):
+        sio = self.sio
+
+        @sio.on("connect", namespace=namespace)
+        async def _on_conn():
+            if self.log:
+                self.log.info("WS connected %s", namespace)
+            self._emit_event("socket.connect", {"ns": namespace})
+
+        @sio.on("disconnect", namespace=namespace)
+        async def _on_disc():
+            if self.log:
+                self.log.info("WS disconnected %s", namespace)
+            self._emit_event("socket.disconnect", {"ns": namespace})
+
+        @sio.event
+        async def connect_error(err):
+            if self.log:
+                self.log.warning("WS connect_error: %s", err)
+            self._emit_event("socket.connect_error", err)
+
+        @sio.on("app:modules:parameters:change", namespace=namespace)
+        async def _on_params_change(payload):
+            self._emit_change(payload)
+
+        @sio.on("app:modules:activity:quantity", namespace=namespace)
+        async def _on_act_qty(payload):
+            self._emit_event("app:modules:activity:quantity", payload)
+
+    async def start_ws(self, jwt: str, namespace: str | None = None) -> None:
+        ns = namespace or self._ns
+        self._ns = ns
+        if self.sio is None:
+            self.sio = socketio.AsyncClient(reconnection=True)
+            self._wire_handlers(ns)
+
+        headers = {
+            "Authorization": f"Bearer {jwt}",
+            "Origin": ONE_BASE,
+            "Referer": f"{ONE_BASE}/",
+        }
+        await self.sio.connect(
+            IO_BASE,                      # python-socketio sam zrobi upgrade do WS
+            namespaces=[ns],
+            transports=["websocket"],
+            socketio_path=SOCK_PATH,
+            headers=headers,
+        )
+        # zapamiętaj SID (zarówno namespacowy jak i engine.io fallback)
+        try:
+            sid_ns = self.sio.get_sid(ns)
+        except Exception:
+            sid_ns = None
+        self._ws_sid = sid_ns or getattr(self.sio, "sid", None)
+
+    async def subscribe(self, devs: list[str], namespace: str | None = None) -> None:
+        if not self.sio:
+            return
+        ns = namespace or self._ns
+        await self.sio.emit("app:modules:parameters:listen", {"modules": devs}, namespace=ns)
+        await self.sio.emit("app:modules:activity:quantity:listen", {"modules": devs}, namespace=ns)
+
+    async def wait(self) -> None:
+        if self.sio:
+            await self.sio.wait()
+
+    async def disconnect(self) -> None:
+        if self.sio:
+            await self.sio.disconnect()
+            self._ws_sid = None
+

py_bragerone-0.2.4.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: py-bragerone
+Version: 0.2.4
+Summary: Brager One client: REST + WebSocket + label resolver for Home Assistant & tools
+Author: ChatGPT5
+Author-email: MarPi82 <marpi82@users.noreply.github.com>
+Maintainer-email: MarPi82 <marpi82@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) [year] [fullname]
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/marpi82/py-bragerone
+Project-URL: Issues, https://github.com/marpi82/py-bragerone/issues
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: python-socketio[asyncio_client]>=5.11
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Requires-Dist: packaging>=24; extra == "test"
+Dynamic: license-file
+
+# py-bragerone
+
+Python client library for [one.brager.pl](https://one.brager.pl).
+
+Features:
+- **REST API**: login, list modules, parameters snapshot
+- **WebSocket (Socket.IO)**: real-time parameter changes
+- **Labels**: human-readable names & units (safe fallbacks, parser WIP)
+- **Gateway**: thin facade for HA/integrations or console usage
+
+## Install
+
+```bash
+pip install py-bragerone
+```
+## Quick start
+```python
+import asyncio
+from bragerone.gateway import Gateway
+
+async def main():
+    g = Gateway(email="you@example.com", password="secret", object_id=439, lang="en")
+    await g.login()
+    await g.pick_modules()
+    await g.bootstrap_labels()
+    await g.initial_snapshot()
+    await g.start_ws()  # keeps listening
+
+asyncio.run(main())
+```
+
+## CLI
+```bash
+python -m bragerone --email you@example.com --password secret --object-id 439 --lang en --log-level DEBUG
+```
+
+## DEV
+Code under src/bragerone/
+Tests in tests/
+Run tests: pytest -q
+
+### License
+[MIT](LICENSE.md) © MarPi82
+

py_bragerone-0.2.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+bragerone/__init__.py,sha256=pOiHysImCgZcDcj0Ij-HrUJ1bSf1G8e6W-KkdhqRgco,260
+bragerone/__main__.py,sha256=WYAQHZjV5MtWY-wLuR3lFt73TpTLtyBKgCrVyn4Bjac,1109
+bragerone/api.py,sha256=OWoyGV0hQIu3XTsrJgq4auKq6VkNbHMrrHlQD344_aU,4744
+bragerone/const.py,sha256=hQbbHKbMCWGatJzDtyAKWpW9t2B7dTrvuTxMEXg_dNQ,348
+bragerone/gateway.py,sha256=vNb_EZQDOvUz2KcsRnxr0ktkY-Sd4Yjc6t97WkHV3RU,7053
+bragerone/labels.py,sha256=OM3rkk14cJozGbkOwBMnJRxBdw8zPxoo5y7N_-eGOqY,3013
+bragerone/ws.py,sha256=izfEvy5xScJTgUIsAd4mUNkKWGbhx0r6AGAbpL5uyQQ,4085
+py_bragerone-0.2.4.dist-info/licenses/LICENSE,sha256=ACwmltkrXIz5VsEQcrqljq-fat6ZXAMepjXGoe40KtE,1069
+py_bragerone-0.2.4.dist-info/METADATA,sha256=zE8D6ryd8hI-bwQav8UdMPrerO76shxJztct-P0sNqI,3338
+py_bragerone-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+py_bragerone-0.2.4.dist-info/entry_points.txt,sha256=Sk_lJskMh5W9PbX2UGaKXdsjiKT60nVPnX7CfdxPz-E,58
+py_bragerone-0.2.4.dist-info/top_level.txt,sha256=X-2TUaMxKl4AEnygGgc85MGRLTIehxYZHZ6delIWskc,10
+py_bragerone-0.2.4.dist-info/RECORD,,

py_bragerone-0.2.4.dist-info/WHEEL

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

py_bragerone-0.2.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bragerone-cli = bragerone.__main__:main

py_bragerone-0.2.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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_bragerone-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+bragerone