omron-connect-api 0.0.3__tar.gz

omron_connect_api-0.0.3/.github/release.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+increment_version() {
+  local delimiter=.
+  local array=($(echo "$1" | tr $delimiter '\n'))
+  array[$2]=$((array[$2]+1))
+  if [ $2 -lt 2 ]; then array[2]=0; fi
+  if [ $2 -lt 1 ]; then array[1]=0; fi
+  echo $(local IFS=$delimiter ; echo "${array[*]}")
+}
+
+apply_bump() {
+  if [ "$1" == "patch" ]; then
+    increment_version "$2" 2
+  elif [ "$1" == "minor" ]; then
+   increment_version "$2" 1
+  elif [ "$1" == "major" ]; then
+   increment_version "$2" 0
+  fi
+}
+
+change_pyproject() {
+  sed -i '' "s/${1}/${2}/g" pyproject.toml
+}
+
+git_tag () {
+  git commit -am "${1}"
+  git tag "${1}" -am "${1}"
+}
+
+BUMP="$1"
+CURRENT="$(grep 'version' pyproject.toml | cut -d\   -f3 | tr -d '"')"
+NEXT="$(apply_bump "$BUMP" "$CURRENT")"
+
+echo "$BUMP - from $CURRENT to $NEXT"
+change_pyproject "$CURRENT" "$NEXT"
+git_tag "$NEXT"

omron_connect_api-0.0.3/.github/workflows/publish.yml

@@ -0,0 +1,55 @@
+name: Build, test and publish
+on: push
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+          cache: 'pip'
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Check lint
+        run: ruff check --output-format=github
+
+      - name: Test
+        run: python3 -m unittest
+
+      - name: Build
+        run: python3 -m build
+
+      - name: Keep artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-to-pypi:
+    if: startsWith(github.ref, 'refs/tags/')  # publish on tag pushes
+    needs:
+      - build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: release
+      url: https://pypi.org/p/omron-connect-api
+
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

omron_connect_api-0.0.3/.gitignore

@@ -0,0 +1,4 @@
+.venv
+
+.coverage
+htmlcov/

omron_connect_api-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 happydev.ca
+
+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.

omron_connect_api-0.0.3/Makefile

@@ -0,0 +1,20 @@
+.PHONY : venv test coverage build release
+
+venv:
+	python3 -m venv .venv && \
+	source .venv/bin/activate && \
+	pip install -r requirements.txt
+
+test:
+	ruff check && \
+	python3 -m unittest
+
+coverage:
+	coverage run --branch -m unittest
+	coverage html
+
+build:
+	python3 -m build
+
+release:
+	.github/release.sh ${bump}

omron_connect_api-0.0.3/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: omron-connect-api
+Version: 0.0.3
+Summary: Library to communicate with OMRON connect API
+Project-URL: Homepage, https://github.com/happydev-ca/omron-connect-api
+Project-URL: Issues, https://github.com/happydev-ca/omron-connect-api/issues
+Author-email: Francois Perron <fperron@gmail.com>
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.13
+Requires-Dist: aiohttp
+Description-Content-Type: text/markdown
+
+[![Build, test and publish](https://github.com/happydev-ca/omron-connect-api/actions/workflows/publish.yml/badge.svg)](https://github.com/happydev-ca/omron-connect-api/actions/workflows/publish.yml)
+
+# omron-connect-api
+
+Library to communicate with OMRON connect API.
+
+## Usage
+
+```python
+import aiohttp
+import asyncio
+import os
+
+from omron_connect_api import OmronConnectApi
+
+
+async def run():
+    async with aiohttp.ClientSession() as session:
+        api = OmronConnectApi(os.environ['EMAIL'], os.environ['PASSWORD'], session)
+        blood_pressure_readings = await api.async_get_blood_pressure_readings()
+        print(blood_pressure_readings)
+
+
+asyncio.run(run())
+```
+
+### Build and test locally
+
+```shell
+make venv
+source .venv/bin/activate
+make test
+make build
+```
+
+### Release version
+
+```shell
+make release bump=patch|minor|major
+```

omron_connect_api-0.0.3/README.md

@@ -0,0 +1,40 @@
+[![Build, test and publish](https://github.com/happydev-ca/omron-connect-api/actions/workflows/publish.yml/badge.svg)](https://github.com/happydev-ca/omron-connect-api/actions/workflows/publish.yml)
+
+# omron-connect-api
+
+Library to communicate with OMRON connect API.
+
+## Usage
+
+```python
+import aiohttp
+import asyncio
+import os
+
+from omron_connect_api import OmronConnectApi
+
+
+async def run():
+    async with aiohttp.ClientSession() as session:
+        api = OmronConnectApi(os.environ['EMAIL'], os.environ['PASSWORD'], session)
+        blood_pressure_readings = await api.async_get_blood_pressure_readings()
+        print(blood_pressure_readings)
+
+
+asyncio.run(run())
+```
+
+### Build and test locally
+
+```shell
+make venv
+source .venv/bin/activate
+make test
+make build
+```
+
+### Release version
+
+```shell
+make release bump=patch|minor|major
+```

omron_connect_api-0.0.3/example.py

@@ -0,0 +1,15 @@
+import aiohttp
+import asyncio
+import os
+
+from omron_connect_api import OmronConnectApi
+
+
+async def run():
+    async with aiohttp.ClientSession() as session:
+        api = OmronConnectApi(os.environ['EMAIL'], os.environ['PASSWORD'], session)
+        blood_pressure_readings = await api.async_get_blood_pressure_readings()
+        print(blood_pressure_readings)
+
+
+asyncio.run(run())

omron_connect_api-0.0.3/omron_connect_api/__init__.py

@@ -0,0 +1,5 @@
+from .blood_pressure.blood_pressure_reading import BloodPressureReading
+from .omron_connect_api_errors import OmronConnectAPIError
+from .omron_connect_api import OmronConnectApi
+
+__all__ = ['BloodPressureReading', 'OmronConnectAPIError', 'OmronConnectApi']

omron_connect_api-0.0.3/omron_connect_api/blood_pressure/blood_pressure_reading.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TypeAlias
+
+mmHg: TypeAlias = int
+bpm: TypeAlias = int
+count: TypeAlias = int
+
+
+@dataclass()
+class BloodPressureReading:
+    measurement_date: datetime
+    diastolic: mmHg
+    systolic: mmHg
+    pulse: bpm
+    irregular_heart_beats: count
+    movements: count

omron_connect_api-0.0.3/omron_connect_api/blood_pressure/blood_pressure_reading_response.py

@@ -0,0 +1,18 @@
+from datetime import datetime, timezone
+from typing import Any, Dict
+
+from .. import BloodPressureReading
+
+
+class BloodPressureReadingResponse:
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> BloodPressureReading:
+        return BloodPressureReading(
+            measurement_date=datetime.fromtimestamp(int(data['measurementDate'])/1000, timezone.utc),
+            diastolic=data['diastolic'],
+            systolic=data['systolic'],
+            pulse=data['pulse'],
+            irregular_heart_beats=int(data['countIrregularHeartBeat']),
+            movements=data['movementDetect']
+        )

omron_connect_api-0.0.3/omron_connect_api/omron_connect_api.py

@@ -0,0 +1,68 @@
+from datetime import datetime, timedelta
+from logging import getLogger, Logger
+from typing import List
+
+import aiohttp
+
+from . import OmronConnectAPIError, BloodPressureReading
+from .blood_pressure.blood_pressure_reading_response import BloodPressureReadingResponse
+
+LOGGER: Logger = getLogger(__package__)
+
+
+class OmronConnectApi:
+    base_url = 'https://oi-api.ohiomron.com'
+    TOKEN_EXPIRED = timedelta(seconds=1)
+
+    def __init__(self, email_address: str, password: str, session: aiohttp.ClientSession):
+        self.email_address = email_address
+        self.password = password
+        self.session = session
+        self.headers = {'Content-Type': 'application/json'}
+        self.expires_at = datetime.now() - self.TOKEN_EXPIRED
+        self.last_synced_time = 0
+
+    async def async_authenticate(self) -> None:
+        if datetime.now() < self.expires_at:
+            return
+
+        url = '/app/login'
+        json = {'app': 'OCM', 'country': 'CA', 'emailAddress': self.email_address, 'password': self.password}
+        async with await self._post(url, json) as response:
+            body = await response.json()
+            self.headers['Authorization'] = body['accessToken']
+            self.expires_at = datetime.now() + timedelta(seconds=body['expiresIn'])
+
+    async def async_get_blood_pressure_readings(self) -> List[BloodPressureReading]:
+        await self.async_authenticate()
+
+        url = f'/app/v2/sync/bp?nextpaginationKey=0&lastSyncedTime={self.last_synced_time}&phoneIdentifier='
+        async with await self._get(url) as response:
+            json = await response.json()
+            self.last_synced_time = int(json['lastSyncedTime'])
+            return [BloodPressureReadingResponse.from_json(reading) for reading in json['data']]
+
+    async def _post(self, url: str, json: dict) -> aiohttp.ClientResponse:
+        response = await self.session.post(url=f'{self.base_url}{url}', headers=self.headers, json=json)
+        await self._log(url, response, self.headers, json)
+        await self._raise_on_error(response)
+        return response
+
+    async def _get(self, url: str) -> aiohttp.ClientResponse:
+        response = await self.session.get(f'{self.base_url}{url}', headers=self.headers)
+        await self._log(url, response, self.headers)
+        await self._raise_on_error(response)
+        return response
+
+    async def _raise_on_error(self, response: aiohttp.ClientResponse) -> None:
+        body = await response.json()
+        if body['success']:
+            return
+        self.expires_at = datetime.now() - self.TOKEN_EXPIRED
+        self.headers.pop('Authorization', None)
+        raise OmronConnectAPIError(response)
+
+    @staticmethod
+    async def _log(url: str, response: aiohttp.ClientResponse, headers: dict, json: dict = None) -> None:
+        LOGGER.debug(
+            f"{url} : Request[[ headers=[{headers}] json=[{json}] ]] - Response[[ status=[{response.status}] headers=[{dict(response.headers)}] body=[{await response.text()}] ]]")

omron_connect_api-0.0.3/omron_connect_api/omron_connect_api_errors.py

@@ -0,0 +1,10 @@
+import aiohttp
+
+
+class OmronConnectAPIError(aiohttp.ClientResponseError):
+    def __init__(self, error_response: aiohttp.ClientResponse):
+        self.request_info = error_response.request_info
+        self.history = error_response.history
+        self.status = error_response.status
+        self.message = error_response.reason
+        self.headers = error_response.headers

omron_connect_api-0.0.3/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "omron-connect-api"
+version = "0.0.3"
+description = "Library to communicate with OMRON connect API"
+authors = [{ name = "Francois Perron", email = "fperron@gmail.com" }]
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Home Automation",
+]
+
+requires-python = ">=3.13"
+dependencies = ["aiohttp"]
+
+[project.urls]
+Homepage = "https://github.com/happydev-ca/omron-connect-api"
+Issues = "https://github.com/happydev-ca/omron-connect-api/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["omronconnectapi"]

omron_connect_api-0.0.3/requirements.txt

@@ -0,0 +1,11 @@
+# prod
+aiohttp~=3.11.18
+
+# test
+aioresponses~=0.7.8
+
+# dev
+build~=1.2.2
+coverage~=7.8.0
+pip~=25.1.1
+ruff~=0.11.10

omron_connect_api-0.0.3/test/blood_pressure/test_blood_pressure_reading_response.py

@@ -0,0 +1,25 @@
+import unittest
+from datetime import datetime, timezone
+from omron_connect_api.blood_pressure.blood_pressure_reading_response import BloodPressureReadingResponse
+
+
+class TestBloodPressureReadingResponse(unittest.TestCase):
+
+    def test_parses_json(self):
+        reading = BloodPressureReadingResponse.from_json(
+            {
+                'measurementDate': '1747615042000',
+                'diastolic': 82,
+                'systolic': 103,
+                'pulse': 62,
+                'countIrregularHeartBeat': '2',
+                'movementDetect': 1
+            }
+        )
+        datetime_in_utc = datetime(2025, 5, 19, 0, 37, 22, tzinfo=timezone.utc)
+        self.assertEqual(reading.measurement_date, datetime_in_utc)
+        self.assertEqual(reading.diastolic, 82)
+        self.assertEqual(reading.systolic, 103)
+        self.assertEqual(reading.pulse, 62)
+        self.assertEqual(reading.irregular_heart_beats, 2)
+        self.assertEqual(reading.movements, 1)

omron_connect_api-0.0.3/test/omron_connect_server_for_test.py

@@ -0,0 +1,35 @@
+from http import HTTPStatus
+
+from aioresponses import aioresponses
+
+
+class OmronConnectServerForTest:
+    base_url = 'https://oi-api.ohiomron.com'
+
+    def __init__(self):
+        self.server = aioresponses()
+
+    def __enter__(self):
+        self.server.__enter__()
+        return self
+
+    def __exit__(self, *args):
+        self.server.__exit__(*args)
+
+    def prepare_login_response(self, body: dict = None, repeat: bool = True) -> str:
+        if body is None:
+            body = {'success': True, 'accessToken': 'token', 'expiresIn': 3600}
+        self.server.post(f'{self.base_url}/app/login', status=HTTPStatus.OK, payload=body, repeat=repeat)
+        return body.get('accessToken')
+
+    def prepare_blood_pressure_readings_response(self, last_synced_time: int = 0, body: dict = None, repeat: bool = True):
+        if body is None:
+            body = {'success': True, 'data': [], 'lastSyncedTime': 0}
+        url = f'/app/v2/sync/bp?nextpaginationKey=0&lastSyncedTime={last_synced_time}&phoneIdentifier='
+        self.server.get(f'{self.base_url}{url}', status=HTTPStatus.OK, payload=body, repeat=repeat)
+
+    def assert_called_with(self, url, method, *args, **kwargs):
+        self.server.assert_called_with(f'{self.base_url}{url}', method, *args, **kwargs)
+
+    def assert_called_once_with(self, url, method, *args, **kwargs):
+        self.server.assert_called_once_with(f'{self.base_url}{url}', method, *args, **kwargs)

omron_connect_api-0.0.3/test/test_omron_connect_api.py

@@ -0,0 +1,130 @@
+import unittest
+from datetime import datetime, timedelta
+
+import aiohttp
+
+from omron_connect_api import OmronConnectAPIError, OmronConnectApi
+from omron_connect_api.blood_pressure.blood_pressure_reading_response import BloodPressureReadingResponse
+from test.omron_connect_server_for_test import OmronConnectServerForTest
+
+
+class TestOmronConnectAPI(unittest.IsolatedAsyncioTestCase):
+    email_address = 'user@gmail.com'
+    password = 'password'
+
+    async def test_authenticates_with_email_address_and_password(self):
+        with OmronConnectServerForTest() as server:
+            server.prepare_login_response({'success': True, 'accessToken': 'any-token', 'expiresIn': 3600})
+
+            async with aiohttp.ClientSession() as session:
+                api = OmronConnectApi(self.email_address, self.password, session)
+                await api.async_authenticate()
+
+                server.assert_called_with(url='/app/login',
+                                          method='POST',
+                                          headers={'Content-Type': 'application/json'},
+                                          json={
+                                              'app': 'OCM',
+                                              'country': 'CA',
+                                              'emailAddress': self.email_address,
+                                              'password': self.password
+                                          })
+
+                self.assertEqual(api.headers.get('Authorization'), 'any-token')
+                self.assertLess(datetime.now() + timedelta(seconds=3600) - api.expires_at, timedelta(seconds=1))
+
+    async def test_reuse_valid_token(self):
+        with OmronConnectServerForTest() as server:
+            server.prepare_login_response({'success': True, 'accessToken': 'any-token', 'expiresIn': 3600})
+            async with aiohttp.ClientSession() as session:
+                api = OmronConnectApi(self.email_address, self.password, session)
+                await api.async_authenticate()
+                await api.async_authenticate()
+
+                server.assert_called_once_with(url='/app/login',
+                                               method='POST',
+                                               headers={'Content-Type': 'application/json'},
+                                               json={
+                                                   'app': 'OCM',
+                                                   'country': 'CA',
+                                                   'emailAddress': self.email_address,
+                                                   'password': self.password
+                                               })
+
+    async def test_authenticates_error(self):
+        with OmronConnectServerForTest() as server:
+            server.prepare_login_response({'success': False})
+
+            async with aiohttp.ClientSession() as session:
+                api = OmronConnectApi(self.email_address, self.password, session)
+
+                with self.assertRaises(OmronConnectAPIError):
+                    await api.async_authenticate()
+
+    async def test_clear_headers_on_error(self):
+        with OmronConnectServerForTest() as server:
+            server.prepare_login_response({'success': False})
+
+            async with aiohttp.ClientSession() as session:
+                api = OmronConnectApi(self.email_address, self.password, session)
+                api.headers['Authorization'] = 'any-token'
+
+                with self.assertRaises(OmronConnectAPIError):
+                    await api.async_authenticate()
+                self.assertEqual(api.headers.get('Authorization'), None)
+                self.assertLess(datetime.now() - api.TOKEN_EXPIRED - api.expires_at, timedelta(seconds=1))
+
+
+    async def test_get_blood_pressure_readings(self):
+        with OmronConnectServerForTest() as server:
+            token = server.prepare_login_response()
+            response = {
+                'success': True,
+                'lastSyncedTime': 1747615042001,
+                'data': [
+                    {
+                        'measurementDate': '1747615042000',
+                        'diastolic': 82,
+                        'systolic': 103,
+                        'pulse': 62,
+                        'countIrregularHeartBeat': 2,
+                        'movementDetect': 1
+                    },
+                    {
+                        'measurementDate': '1747615062000',
+                        'diastolic': 72,
+                        'systolic': 100,
+                        'pulse': 64,
+                        'countIrregularHeartBeat': 0,
+                        'movementDetect': 0
+                    }
+                ]
+            }
+            server.prepare_blood_pressure_readings_response(0, response)
+            async with aiohttp.ClientSession() as session:
+                api = OmronConnectApi(self.email_address, self.password, session)
+                readings = await api.async_get_blood_pressure_readings()
+
+                server.assert_called_with(
+                    url='/app/v2/sync/bp?nextpaginationKey=0&lastSyncedTime=0&phoneIdentifier=',
+                    method='GET',
+                    headers={'Content-Type': 'application/json', 'Authorization': token})
+
+                expected_readings = [BloodPressureReadingResponse.from_json(reading) for reading in response['data']]
+                self.assertEqual(readings, expected_readings)
+                self.assertEqual(api.last_synced_time, 1747615042001)
+
+    async def test_get_blood_pressure_readings_from_last_synced_time(self):
+        with OmronConnectServerForTest() as server:
+            token = server.prepare_login_response()
+            server.prepare_blood_pressure_readings_response(last_synced_time=1747615042001)
+
+            async with aiohttp.ClientSession() as session:
+                api = OmronConnectApi(self.email_address, self.password, session)
+                api.last_synced_time = 1747615042001
+                await api.async_get_blood_pressure_readings()
+
+                server.assert_called_with(
+                    url='/app/v2/sync/bp?nextpaginationKey=0&lastSyncedTime=1747615042001&phoneIdentifier=',
+                    method='GET',
+                    headers={'Content-Type': 'application/json', 'Authorization': token})