py-bragerone 0.2.4__tar.gz

py_bragerone-0.2.4/.github/workflows/publish.yml

@@ -0,0 +1,96 @@
+name: CI / Publish (TestPyPI & PyPI)
+
+on:
+  push:
+    branches: [ "main" ]
+    tags:
+      - "v*.*.*"
+  workflow_dispatch: {}
+
+jobs:
+  build-and-test:
+    name: Build & Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout (with tags)
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # potrzebne dla setuptools-scm
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Cache pip
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/pyproject.toml') }}
+
+      - name: Install build & test deps
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .[test] build
+          # Jeśli nie masz extra "test", zamień na: pip install -r requirements.txt -r requirements-dev.txt
+
+      - name: Run tests
+        run: pytest -q
+
+      - name: Build sdist + wheel
+        run: python -m build
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/*
+
+  publish-testpypi:
+    name: Publish dev to TestPyPI (on push to main)
+    needs: build-and-test
+    if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/heads/main') }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          skip-existing: true  # nie wywali się, jeśli ta wersja już jest
+
+      - name: Smoke test install from TestPyPI
+        run: |
+          python -m venv .venv
+          . .venv/bin/activate
+          python -m pip install --upgrade pip
+          pip install --index-url https://test.pypi.org/simple/ \
+                      --extra-index-url https://pypi.org/simple \
+                      py-bragerone
+          python - <<'PY'
+          import bragerone as m
+          print("Imported OK:", getattr(m, "__version__", "no __version__"))
+          PY
+
+  publish-pypi:
+    name: Publish release to PyPI (on tag vX.Y.Z)
+    needs: build-and-test
+    if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          skip-existing: false
+

py_bragerone-0.2.4/.gitignore

@@ -0,0 +1,85 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+*.pyc
+*.pyo
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# PyCharm / VS Code
+.idea/
+.vscode/
+
+# mypy / type checker
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pyre/
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Mac / Windows system files
+.DS_Store
+Thumbs.db
+
+# local
+labels_debug.log
+.assets/
+*.save
+py-bragerone.*

py_bragerone-0.2.4/CHANGELOG.md

@@ -0,0 +1,25 @@
+---
+
+## `CHANGELOG.md`
+
+```markdown
+# Changelog
+
+## [0.2.0] - 2025-09-08
+### Added
+- Split into modules: `api.py`, `ws.py`, `gateway.py`, `labels.py`, `const.py`.
+- CLI entrypoint `bragerone` with `--email/--password/--object-id/--lang/--log-level`.
+- Initial snapshot fetch and WS subscription (parameters & activity).
+- Human-readable change logs with previous → new value.
+
+### Changed
+- Refactor: Gateway orchestrates REST + WS; API handles REST; WS handles socket wiring; labels kept standalone.
+- Logging cleanup and levels clarified (INFO/DEBUG).
+
+### Fixed
+- Stable WS connect (namespace `/ws`, correct socket.io path, auth header).
+- Robust modules listing and device selection.
+
+## [0.1.0] - 2025-09-01
+### Added
+- Initial working version (REST + WS combined).

py_bragerone-0.2.4/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,44 @@
+# 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/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=69", "setuptools-scm>=8", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "py-bragerone"
+dynamic = ["version"]  # wersja zaciągana z tagów git (setuptools-scm)
+description = "Brager One client: REST + WebSocket + label resolver for Home Assistant & tools"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+  { name = "MarPi82", email = "marpi82@users.noreply.github.com" },
+  { name = "ChatGPT5" }
+]
+maintainers = [
+  { name = "MarPi82", email = "marpi82@users.noreply.github.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+  "aiohttp>=3.9",
+  "python-socketio[asyncio_client]>=5.11",
+]
+
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: OS Independent",
+  "Topic :: Home Automation",
+]
+
+[project.urls]
+Homepage = "https://github.com/marpi82/py-bragerone"
+Issues   = "https://github.com/marpi82/py-bragerone/issues"
+
+[project.scripts]
+bragerone-cli = "bragerone.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+# --- setuptools-scm konfiguracja ---
+[tool.setuptools_scm]
+# Domyślnie akceptuje tagi w stylu v1.2.3 lub 1.2.3; nie musisz nic zmieniać.
+# Jeśli budujesz z commita bez taga, dostaniesz wersję dev/post:
+version_scheme = "guess-next-dev"
+local_scheme = "no-local-version"
+fallback_version = "0.0.0"
+
+[project.optional-dependencies]
+test = [
+  "pytest>=8",
+  "pytest-asyncio>=0.23",
+  "packaging>=24",
+]

py_bragerone-0.2.4/pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+addopts = -q
+filterwarnings =
+    ignore::DeprecationWarning

py_bragerone-0.2.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_bragerone-0.2.4/src/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__"]

py_bragerone-0.2.4/src/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())

py_bragerone-0.2.4/src/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
+

py_bragerone-0.2.4/src/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"

py_bragerone-0.2.4/src/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)
+

py_bragerone-0.2.4/src/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}"
+

py_bragerone-0.2.4/src/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/src/py_bragerone.egg-info/PKG-INFO

@@ -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/src/py_bragerone.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+.gitignore
+CHANGELOG.md
+LICENSE
+README.md
+pyproject.toml
+pytest.ini
+.github/workflows/publish.yml
+src/bragerone/__init__.py
+src/bragerone/__main__.py
+src/bragerone/api.py
+src/bragerone/const.py
+src/bragerone/gateway.py
+src/bragerone/labels.py
+src/bragerone/ws.py
+src/py_bragerone.egg-info/PKG-INFO
+src/py_bragerone.egg-info/SOURCES.txt
+src/py_bragerone.egg-info/dependency_links.txt
+src/py_bragerone.egg-info/entry_points.txt
+src/py_bragerone.egg-info/requires.txt
+src/py_bragerone.egg-info/top_level.txt
+tests/test_api.py
+tests/test_labels.py
+tests/test_version.py
+tests/test_ws.py

py_bragerone-0.2.4/src/py_bragerone.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_bragerone-0.2.4/src/py_bragerone.egg-info/entry_points.txt

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

py_bragerone-0.2.4/src/py_bragerone.egg-info/requires.txt

@@ -0,0 +1,7 @@
+aiohttp>=3.9
+python-socketio[asyncio_client]>=5.11
+
+[test]
+pytest>=8
+pytest-asyncio>=0.23
+packaging>=24

py_bragerone-0.2.4/src/py_bragerone.egg-info/top_level.txt

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

py_bragerone-0.2.4/tests/test_api.py

@@ -0,0 +1,25 @@
+import pytest
+from bragerone.api import Api
+
+def test_gateway_is_exposed_on_top_level():
+    import bragerone
+    assert hasattr(bragerone, "Gateway"), "Gateway nie jest eksportowany w __all__"
+    # opcjonalnie: sprawdź, że to klasa
+    assert isinstance(bragerone.Gateway, type)
+
+@pytest.mark.asyncio
+async def test_api_construct():
+    a = Api()
+    assert a.jwt is None
+
+@pytest.mark.asyncio
+async def test_api_login_monkeypatch(monkeypatch):
+    api = Api()
+
+    async def fake_req(method, url, **kw):
+        return {"accessToken": "abc"}
+    monkeypatch.setattr(api, "_req", fake_req)
+
+    data = await api.login("x","y")
+    assert api.jwt == "abc"
+    assert "accessToken" in data

py_bragerone-0.2.4/tests/test_labels.py

@@ -0,0 +1,38 @@
+import asyncio
+import pytest
+from bragerone.labels import LabelFetcher
+
+
+@pytest.mark.asyncio
+async def test_labels_bootstrap_no_crash():
+    """Bootstrap shouldn’t crash and counters should be integers."""
+    lf = LabelFetcher()
+    # current implementation is a no-op; must not raise
+    await lf.bootstrap(lang="pl")
+    assert isinstance(lf.count_vars(), int)
+    assert isinstance(lf.count_langs(), int)
+
+
+def test_param_label_unknown_returns_none():
+    """
+    With the current minimal label store, unknown params have no label.
+    That’s fine — higher layers can fall back to raw names.
+    """
+    lf = LabelFetcher()
+    assert lf.param_label("P6", 7, "pl") is None
+
+
+def test_idempotent_counters():
+    """
+    Counters should remain stable across no-op bootstrap calls.
+    (Regression guard for future changes.)
+    """
+    lf = LabelFetcher()
+    c1_vars = lf.count_vars()
+    c1_langs = lf.count_langs()
+    # pretend we call bootstrap again (still a no-op today)
+    asyncio.get_event_loop().run_until_complete(lf.bootstrap(lang="pl"))
+    c2_vars = lf.count_vars()
+    c2_langs = lf.count_langs()
+    assert c1_vars == c2_vars
+    assert c1_langs == c2_langs

py_bragerone-0.2.4/tests/test_version.py

@@ -0,0 +1,14 @@
+from importlib.metadata import version, PackageNotFoundError
+from packaging.version import Version
+
+PKG = "py-bragerone"
+
+def test_version_string_is_parseable():
+    try:
+        v = version(PKG)
+    except PackageNotFoundError:
+        # fallback: import bez instalacji — wersja z __init__.py
+        import bragerone as m
+        v = getattr(m, "__version__", "0.0.0")
+    # parsowalne wg PEP 440 (np. 0.3.0.dev1+gabcdef)
+    Version(v)  # nie rzuci wyjątku, jeśli OK

py_bragerone-0.2.4/tests/test_ws.py

@@ -0,0 +1,15 @@
+from bragerone.ws import WsClient
+from bragerone.api import Api
+
+def test_ws_construct():
+    w = WsClient(Api())
+    assert w.api is not None
+
+def test_ws_callbacks_collect():
+    ws = WsClient(lambda: "tok")
+    seen = {}
+    ws.add_event_cb(lambda n,d: seen.setdefault("e", 0) or seen.__setitem__("e", 1))
+    ws.add_change_cb(lambda p: seen.setdefault("c", 0) or seen.__setitem__("c", 1))
+    ws._emit_event("x", {})
+    ws._emit_change({})
+    assert seen["e"] == 1 and seen["c"] == 1