myconso 0.0.1__tar.gz

myconso-0.0.1/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# 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
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.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/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

myconso-0.0.1/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: myconso
+Version: 0.0.1
+Summary: Async Python client to interact with myconso.net API
+Project-URL: homepage, https://github.com/remijouannet/myconso.py
+Project-URL: repository, https://github.com/remijouannet/myconso.py
+Author-email: Rémi Jouannet <remijouannet@gmail.com>
+Requires-Python: >=3.10
+Requires-Dist: aiohttp
+Requires-Dist: aiohttp-retry>=2.9.1
+Requires-Dist: pyjwt[crypto]
+Description-Content-Type: text/markdown
+
+
+# Unofficial async python client for myconso (proxiserve) API
+
+Unofficial fully asynchronous API client for the myconso api behind the [Myconso application](https://play.google.com/store/apps/details?id=fr.proxiserve.myconso&hl=fr). To easily retrieve information about your counters (waterhot, watercold, thermal, ...)
+
+## Installation
+
+```bash
+pip install myconso 
+```
+
+## Getting started
+
+### Client
+```python
+import asyncio
+import os
+from datetime import datetime
+from pprint import pprint
+
+from myconso.api import MyConsoClient
+
+MYCONSO_EMAIL = os.getenv("MYCONSO_EMAIL")
+MYCONSO_PASSWORD = os.getenv("MYCONSO_PASSWORD")
+
+
+async def main():
+    async with MyConsoClient(username=MYCONSO_EMAIL, password=MYCONSO_PASSWORD) as c:
+        pprint(await c.get_dashboard())
+        pprint(await c.get_housing())
+
+        ctrs = await c.get_counters()
+        pprint(ctrs)
+
+        pprint(await c.get_meter_info(counter=ctrs[0]["counter"]))
+
+        pprint(await c.get_consumption(fluidtype="waterHot"))
+
+        pprint(
+            await c.get_consumption(
+                fluidtype="waterHot",
+                startdate=datetime(2025, 12, 1),
+                enddate=datetime(2025, 12, 4),
+            )
+        )
+
+        pprint(await c.get_meter(counter=ctrs[0]["counter"]))
+
+        pprint(
+            await c.get_meter(
+                counter=ctrs[0]["counter"],
+                startdate=datetime(2025, 12, 1),
+                enddate=datetime(2025, 12, 4),
+            )
+        )
+
+
+asyncio.run(main())
+```
+### cli
+
+```bash
+.venv/bin/myconsocli --help
+usage: myconsocli [-h] [--debug] --email EMAIL --password PASSWORD [--auth] [--dashboard] [--counters] [--housing] [--user] [--meter-info METER_INFO]
+                  [--meter METER] [--consumption CONSUMPTION] [--start-date START_DATE] [--end-date END_DATE]
+
+myconso cli
+
+options:
+  -h, --help            show this help message and exit
+  --debug               enable debug logging
+  --email EMAIL         email
+  --password PASSWORD   password
+  --auth                POST auth/
+  --dashboard           GET /secured/consumption/{housing}/dashboard
+  --counters            List counters from dashboard
+  --housing             GET /secured/housing/{housing}
+  --user                GET /secured/users/{user}
+  --meter-info METER_INFO
+                        GET /secured/meter/{housing}/{fluidType}/{counter}/info
+  --meter METER         GET /secured/meter/{housing}/{fluidType}/{counter}
+  --consumption CONSUMPTION
+                        /secured/consumption/{housing}/{fluidtype}/day
+  --start-date START_DATE
+                        start date for consumption and meter
+  --end-date END_DATE   end date for consumption and meter
+
+.venv/bin/myconsocli --email $MYCONSO_EMAIL --password $MYCONSO_PASSWORD --dashboard
+{'currentMonth': {'endDate': '2025-12-13T12:01:00+00:00',
+                  'startDate': '2025-12-01T17:25:19+00:00',
+                  'values': [{'counters': ['123456'],
+                              'fluidType': 'waterHot',
+                              'maxValue': 1.0,
+                              'meterType': 'waterHot',
+                              'minValue': 1.0,
+                              'unit': 'm3',
+                              'value': 1.0,
+                              'weightedValue': None},
+                             }
+
+.venv/bin/myconsocli --email $MYCONSO_EMAIL --password $MYCONSO_PASSWORD --meter-info 123456789
+{}
+
+.venv/bin/myconsocli --email $MYCONSO_EMAIL --password $MYCONSO_PASSWORD --meter 123456789 --start-date 2025-11-01 --end-date 2025-11-05
+{}
+```

myconso-0.0.1/README.md

@@ -0,0 +1,106 @@
+
+# Unofficial async python client for myconso (proxiserve) API
+
+Unofficial fully asynchronous API client for the myconso api behind the [Myconso application](https://play.google.com/store/apps/details?id=fr.proxiserve.myconso&hl=fr). To easily retrieve information about your counters (waterhot, watercold, thermal, ...)
+
+## Installation
+
+```bash
+pip install myconso 
+```
+
+## Getting started
+
+### Client
+```python
+import asyncio
+import os
+from datetime import datetime
+from pprint import pprint
+
+from myconso.api import MyConsoClient
+
+MYCONSO_EMAIL = os.getenv("MYCONSO_EMAIL")
+MYCONSO_PASSWORD = os.getenv("MYCONSO_PASSWORD")
+
+
+async def main():
+    async with MyConsoClient(username=MYCONSO_EMAIL, password=MYCONSO_PASSWORD) as c:
+        pprint(await c.get_dashboard())
+        pprint(await c.get_housing())
+
+        ctrs = await c.get_counters()
+        pprint(ctrs)
+
+        pprint(await c.get_meter_info(counter=ctrs[0]["counter"]))
+
+        pprint(await c.get_consumption(fluidtype="waterHot"))
+
+        pprint(
+            await c.get_consumption(
+                fluidtype="waterHot",
+                startdate=datetime(2025, 12, 1),
+                enddate=datetime(2025, 12, 4),
+            )
+        )
+
+        pprint(await c.get_meter(counter=ctrs[0]["counter"]))
+
+        pprint(
+            await c.get_meter(
+                counter=ctrs[0]["counter"],
+                startdate=datetime(2025, 12, 1),
+                enddate=datetime(2025, 12, 4),
+            )
+        )
+
+
+asyncio.run(main())
+```
+### cli
+
+```bash
+.venv/bin/myconsocli --help
+usage: myconsocli [-h] [--debug] --email EMAIL --password PASSWORD [--auth] [--dashboard] [--counters] [--housing] [--user] [--meter-info METER_INFO]
+                  [--meter METER] [--consumption CONSUMPTION] [--start-date START_DATE] [--end-date END_DATE]
+
+myconso cli
+
+options:
+  -h, --help            show this help message and exit
+  --debug               enable debug logging
+  --email EMAIL         email
+  --password PASSWORD   password
+  --auth                POST auth/
+  --dashboard           GET /secured/consumption/{housing}/dashboard
+  --counters            List counters from dashboard
+  --housing             GET /secured/housing/{housing}
+  --user                GET /secured/users/{user}
+  --meter-info METER_INFO
+                        GET /secured/meter/{housing}/{fluidType}/{counter}/info
+  --meter METER         GET /secured/meter/{housing}/{fluidType}/{counter}
+  --consumption CONSUMPTION
+                        /secured/consumption/{housing}/{fluidtype}/day
+  --start-date START_DATE
+                        start date for consumption and meter
+  --end-date END_DATE   end date for consumption and meter
+
+.venv/bin/myconsocli --email $MYCONSO_EMAIL --password $MYCONSO_PASSWORD --dashboard
+{'currentMonth': {'endDate': '2025-12-13T12:01:00+00:00',
+                  'startDate': '2025-12-01T17:25:19+00:00',
+                  'values': [{'counters': ['123456'],
+                              'fluidType': 'waterHot',
+                              'maxValue': 1.0,
+                              'meterType': 'waterHot',
+                              'minValue': 1.0,
+                              'unit': 'm3',
+                              'value': 1.0,
+                              'weightedValue': None},
+                             }
+
+.venv/bin/myconsocli --email $MYCONSO_EMAIL --password $MYCONSO_PASSWORD --meter-info 123456789
+{}
+
+.venv/bin/myconsocli --email $MYCONSO_EMAIL --password $MYCONSO_PASSWORD --meter 123456789 --start-date 2025-11-01 --end-date 2025-11-05
+{}
+```

myconso-0.0.1/myconso/api.py

@@ -0,0 +1,248 @@
+import asyncio
+import logging
+import time
+from datetime import datetime
+from types import TracebackType
+
+from aiohttp import ClientHandlerType, ClientRequest, ClientResponse, ClientSession
+
+from myconso.middlewares import exponential_backoff_middleware
+from myconso.utils import (
+    clean_json_ld,
+    decode_jwt,
+    first_day_of_the_month,
+    last_day_of_the_month,
+)
+
+log = logging.getLogger(__name__)
+
+MYCONSO_API = "https://api.myconso.net"
+MYCONSO_USER_AGENT = "MyConso"
+
+
+def check_auth(func):
+    async def wrapper(self, *args, **kwargs):
+        if not self.token and (self.username and self.password):
+            # class has been initialized with username/password
+            async with self.lock:
+                await self.auth()
+        elif not self._housing and self.token and self.refresh_token:
+            # class has been initialized with token/refresh_token
+            async with self.lock:
+                await self.auth_refresh()
+        return await func(self, *args, **kwargs)
+
+    return wrapper
+
+
+class MyConsoClient:
+    username: str | None
+    password: str | None
+    token: str | None
+    refresh_token: str | None
+    _counters: list[dict]
+
+    def __init__(
+        self,
+        username: str | None = None,
+        password: str | None = None,
+        token: str | None = None,
+        refresh_token: str | None = None,
+    ) -> None:
+        if token and refresh_token:
+            self.token = token
+            self.token_exp, self.token_iat = decode_jwt(self.token)
+            self.refresh_token = refresh_token
+        elif username and password:
+            self.token = None
+            self.refresh_token = None
+            self.username = username
+            self.password = password
+        else:
+            raise ValueError(
+                "You must either provide username/password or token/refresh_token"
+            )
+
+        self._housing = None
+        self._counters = []
+        self.lock = asyncio.Lock()
+        self.session = ClientSession(
+            base_url=MYCONSO_API,
+            headers={"user-agent": MYCONSO_USER_AGENT},
+            raise_for_status=True,
+            middlewares=(
+                exponential_backoff_middleware,
+                self._auth_refresh_middleware,
+            ),
+        )
+
+    async def __aenter__(self) -> "MyConsoClient":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        await self.session.close()
+
+    async def _auth_refresh_middleware(
+        self, req: ClientRequest, handler: ClientHandlerType
+    ) -> ClientResponse:
+        epoch_now = time.time()
+        if epoch_now > self.token_exp:
+            log.debug(
+                "token is expired, refresh it, exp: %s, time: %s",
+                self.token_exp,
+                epoch_now,
+            )
+            async with self.lock:
+                await self.auth_refresh()
+
+        for _ in range(2):
+            res = await handler(req)
+            if res.status in {401}:
+                log.debug("received %s, try to refresh the bearer token", res.status)
+                async with self.lock:
+                    await self.auth_refresh()
+            else:
+                return res
+
+        return res
+
+    async def auth(self) -> dict:
+        async with self.session.post(
+            "/auth",
+            json={
+                "email": self.username,
+                "password": self.password,
+            },
+            middlewares=(),
+        ) as res:
+            res = await res.json()
+            self._user = res["user"]["email"]
+            self._housing = res["housing"]
+            self.token = res["token"]
+            self.refresh_token = res["refresh_token"]
+            self.token_exp, self.token_iat = decode_jwt(self.token)
+            self.session.headers.update({"authorization": f"Bearer {self.token}"})
+
+            log.debug("successful authentification for housing: %s", self._housing)
+
+            return res
+
+    async def auth_refresh(self) -> dict:
+        async with self.session.post(
+            "/auth/refresh",
+            json={
+                "refresh_token": self.refresh_token,
+            },
+            middlewares=(),
+        ) as res:
+            res = await res.json()
+            self._user = res["user"]["email"]
+            self._housing = res["housing"]
+            self.token = res["token"]
+            self.refresh_token = res["refresh_token"]
+            self.token_exp, self.token_iat = decode_jwt(self.token)
+            self.session.headers["authorization"] = f"Bearer {self.token}"
+
+            return res
+
+    @check_auth
+    async def get_user(self) -> dict:
+        async with self.session.get(f"/secured/users/{self._user}") as res:
+            return clean_json_ld(await res.json())
+
+    @check_auth
+    async def get_housing(self) -> dict:
+        async with self.session.get(f"/secured/housing/{self._housing}") as res:
+            return clean_json_ld(await res.json())
+
+    @check_auth
+    async def get_dashboard(self) -> dict:
+        async with self.session.get(
+            f"/secured/consumption/{self._housing}/dashboard"
+        ) as res:
+            return clean_json_ld(await res.json())
+
+    @check_auth
+    async def get_counters(self) -> list[dict]:
+        if not self._counters:
+            res = await self.get_dashboard()
+            for v in res["currentMonth"]["values"]:
+                for counter in v["counters"]:
+                    self._counters.append(
+                        {
+                            "counter": counter,
+                            "fluidType": v["fluidType"],
+                            "meterType": v["meterType"],
+                            "unit": v["unit"],
+                        }
+                    )
+        return self._counters
+
+    @check_auth
+    async def get_consumption(
+        self,
+        fluidtype: str,
+        startdate: datetime | None = None,
+        enddate: datetime | None = None,
+    ) -> dict | None:
+        if not startdate:
+            startdate = first_day_of_the_month()
+        if not enddate:
+            enddate = last_day_of_the_month()
+
+        async with self.session.get(
+            f"/secured/consumption/{self._housing}/{fluidtype}/day",
+            params={
+                "startDate": startdate.isoformat(timespec="milliseconds"),
+                "endDate": enddate.isoformat(timespec="milliseconds"),
+            },
+        ) as res:
+            return clean_json_ld(await res.json())
+
+    @check_auth
+    async def get_meter_info(self, counter: str) -> dict | None:
+        if not self._counters:
+            await self.get_counters()
+
+        for c in self._counters:
+            if c["counter"] == counter:
+                async with self.session.get(
+                    f"/secured/meter/{self._housing}/{c['fluidType']}/{c['counter']}/info",
+                ) as res:
+                    return clean_json_ld(await res.json())
+        return None
+
+    @check_auth
+    async def get_meter(
+        self,
+        counter: str,
+        startdate: datetime | None = None,
+        enddate: datetime | None = None,
+    ) -> dict | None:
+        if not startdate:
+            startdate = first_day_of_the_month()
+        if not enddate:
+            enddate = last_day_of_the_month()
+
+        if not self._counters:
+            await self.get_counters()
+
+        for c in self._counters:
+            if c["counter"] == counter:
+                async with self.session.get(
+                    f"/secured/meter/{self._housing}/{c['fluidType']}/{c['counter']}",
+                    params={
+                        "startDate": startdate.isoformat(timespec="milliseconds"),
+                        "endDate": enddate.isoformat(timespec="milliseconds"),
+                    },
+                ) as res:
+                    return clean_json_ld(await res.json())
+        return None

myconso-0.0.1/myconso/cli.py

@@ -0,0 +1,139 @@
+import argparse
+import asyncio
+import datetime
+import logging
+from pprint import pprint
+
+from myconso.api import MyConsoClient
+
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger(__name__)
+
+
+async def cli() -> None:
+    parser = argparse.ArgumentParser(description="myconso cli")
+    parser.add_argument(
+        "--debug",
+        dest="debug",
+        default=False,
+        action="store_true",
+        help="enable debug logging",
+    )
+    parser.add_argument(
+        "--email",
+        dest="email",
+        type=str,
+        required=True,
+        help="email",
+    )
+    parser.add_argument(
+        "--password",
+        dest="password",
+        type=str,
+        required=True,
+        help="password",
+    )
+    parser.add_argument(
+        "--auth",
+        dest="auth",
+        default=False,
+        action="store_true",
+        help="POST auth/",
+    )
+    parser.add_argument(
+        "--dashboard",
+        dest="dashboard",
+        default=False,
+        action="store_true",
+        help="GET /secured/consumption/{housing}/dashboard",
+    )
+    parser.add_argument(
+        "--counters",
+        dest="counters",
+        default=False,
+        action="store_true",
+        help="List counters from dashboard",
+    )
+    parser.add_argument(
+        "--housing",
+        dest="housing",
+        default=False,
+        action="store_true",
+        help="GET /secured/housing/{housing}",
+    )
+    parser.add_argument(
+        "--user",
+        dest="user",
+        default=False,
+        action="store_true",
+        help="GET /secured/users/{user}",
+    )
+    parser.add_argument(
+        "--meter-info",
+        dest="meter_info",
+        default=None,
+        type=str,
+        help="GET /secured/meter/{housing}/{fluidType}/{counter}/info",
+    )
+    parser.add_argument(
+        "--meter",
+        dest="meter",
+        default=None,
+        type=str,
+        help="GET /secured/meter/{housing}/{fluidType}/{counter}",
+    )
+    parser.add_argument(
+        "--consumption",
+        dest="consumption",
+        default=None,
+        type=str,
+        help="/secured/consumption/{housing}/{fluidtype}/day",
+    )
+    parser.add_argument(
+        "--start-date",
+        dest="start_date",
+        default=None,
+        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
+        help="start date for consumption and meter",
+    )
+    parser.add_argument(
+        "--end-date",
+        dest="end_date",
+        default=None,
+        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
+        help="end date for consumption and meter",
+    )
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+        log.debug('debug enabled')
+
+    async with MyConsoClient(username=args.email, password=args.password) as myconso:
+        if args.auth:
+            pprint(await myconso.auth())
+        elif args.dashboard:
+            pprint(await myconso.get_dashboard())
+        elif args.counters:
+            pprint(await myconso.get_counters())
+        elif args.housing:
+            pprint(await myconso.get_housing())
+        elif args.user:
+            pprint(await myconso.get_user())
+        elif args.meter_info:
+            pprint(await myconso.get_meter_info(args.meter_info))
+        elif args.meter:
+            pprint(await myconso.get_meter(args.meter, args.start_date, args.end_date))
+        elif args.consumption:
+            pprint(
+                await myconso.get_consumption(
+                    args.consumption, args.start_date, args.end_date
+                )
+            )
+        else:
+            pprint(await myconso.get_dashboard())
+
+
+def main() -> None:
+    asyncio.run(cli())

myconso-0.0.1/myconso/middlewares.py

@@ -0,0 +1,35 @@
+import asyncio
+import logging
+import random
+
+from aiohttp import ClientHandlerType, ClientRequest, ClientResponse
+
+log = logging.getLogger(__name__)
+
+BACKOFF_STATUS_CODES = {429, 503}
+BACKOFF_MAX_RETRIES = 2
+BACKOFF_FACTOR = 2.0
+BACKOFF_MAX_DELAY = 60.0
+BACKOFF_JITTER = 2
+
+
+async def exponential_backoff_middleware(
+    req: ClientRequest, handler: ClientHandlerType
+) -> ClientResponse:
+    retry_count = 1
+
+    res = await handler(req)
+    while retry_count <= BACKOFF_MAX_RETRIES:
+        if retry_count < BACKOFF_MAX_RETRIES and res.status in BACKOFF_STATUS_CODES:
+            delay = round(
+                min(BACKOFF_FACTOR * (2**retry_count), BACKOFF_MAX_DELAY)
+                + random.uniform(0, BACKOFF_JITTER),
+                3,
+            )
+            log.debug("retry backoff for %s, sleep for %ss", res.status, str(delay))
+            await asyncio.sleep(delay)
+            retry_count += 1
+            res = await handler(req)
+        else:
+            break
+    return res

myconso-0.0.1/myconso/utils.py

@@ -0,0 +1,45 @@
+import calendar
+from datetime import datetime, timezone
+
+import jwt
+
+
+def clean_json_ld(obj: dict) -> dict:
+    # json-ld add keys that starts with @
+    # we don't need thoses, pop them
+    if isinstance(obj, dict):
+        keys_to_pop = [key for key in obj if key.startswith("@")]
+        for key in keys_to_pop:
+            obj.pop(key, None)
+    return obj
+
+
+def decode_jwt(token: str) -> tuple[int, int]:
+    token_jwt = jwt.decode(
+        token,
+        algorithms=["RS256"],
+        key="",
+        options={"verify_signature": False},
+    )
+    return (token_jwt["exp"], token_jwt["iat"])
+
+
+def last_day_of_the_month() -> datetime:
+    # last day of the current month
+    return datetime.now(timezone.utc).replace(
+        day=calendar.monthrange(
+            datetime.now(timezone.utc).year,
+            datetime.now(timezone.utc).month,
+        )[1],
+        hour=23,
+        minute=59,
+        second=59,
+        microsecond=0,
+    )
+
+
+def first_day_of_the_month() -> datetime:
+    # first day of the current month
+    return datetime.now(timezone.utc).replace(
+        day=1, hour=0, minute=0, second=0, microsecond=0
+    )

myconso-0.0.1/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "myconso"
+version = "0.0.1"
+description = "Async Python client to interact with myconso.net API"
+readme = "README.md"
+authors = [
+    {name = "Rémi Jouannet", email = "remijouannet@gmail.com"},
+]
+requires-python = ">=3.10"
+packages = [
+    { include = "myconso" }
+]
+dependencies = [
+    "aiohttp",
+    "aiohttp-retry>=2.9.1",
+    "pyjwt[crypto]",
+]
+
+[project.urls]
+homepage = "https://github.com/remijouannet/myconso.py"
+repository = "https://github.com/remijouannet/myconso.py"
+
+[project.scripts]
+myconsocli = "myconso.cli:main"
+
+[dependency-groups]
+dev = [
+    "ruff",
+    "mypy",
+    "pre-commit>=4.2.0",
+    "pytest>=9.0.1",
+    "pytest-asyncio>=1.3.0",
+    "pytest-aiohttp>=1.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "myconso/*",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["myconso"]
+only-packages = true
+
+[tool.ruff]
+line-length = 88
+include = ["tests/*.py", "myconso/*.py"]
+
+[tool.ruff.lint]
+select = [
+    # flake8-async
+    "ASYNC",
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pyupgrade
+    "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+    # ruff
+    "RUF",
+    # flake8-quotes
+    "Q"
+]
+
+[tool.mypy]
+exclude = "tests/"
+files = "myconso/*.py"