pylibrelinkup 0.0.1__tar.gz

pylibrelinkup-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rob Berwick
+
+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.

pylibrelinkup-0.0.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.1
+Name: pylibrelinkup
+Version: 0.0.1
+Summary: A client for the Abbott LibreLinkUp API
+Author-email: Rob Berwick <rob.berwick@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Rob Berwick
+        
+        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/robberwick/pylibrelinkup
+Project-URL: Issues, https://github.com/robberwick/pylibrelinkup/issues
+Keywords: librelink,librelinkup,abbott,diabetes,glucose,api,client,health,medical,blood-sugar,continuous-glucose-monitoring,cgm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pydantic>=2.5.0
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: polyfactory; extra == "test"
+Requires-Dist: responses; extra == "test"
+
+# pylibrelinkup
+
+`pylibrelinkup` is a Python client for the LibreLinkUp API, which allows you to interact with the LibreLinkUp service to retrieve glucose data and other related information. This project is a Python implementation inspired by the [libre-link-up-api-client](https://github.com/DiaKEM/libre-link-up-api-client) project.
+
+## Installation
+
+To install `pylibrelinkup`, you can use `pip`:
+
+```bash
+pip install pylibrelinkup
+```
+
+## Usage
+
+### Initialization
+
+First, you need to import the necessary modules, initialize the client, and authenticate with your LibreLinkUp credentials:
+
+```python
+from pylibrelinkup.client import LibreLinkUpClient
+
+client = LibreLinkUpClient(username='your_username', password='your_password')
+client.authenticate()
+```
+
+### Getting Patient List
+
+You can fetch the patient list using the `get_patient_list` method:
+
+```python
+patient_list = client.get_patient_list()
+print(patient_list)
+```
+
+### Getting Patient data
+
+Retrieve patient data using the `get_graph_data` method:
+
+```python
+patient = client.get_patient_list()[0]
+patient_data = client.get_graph_data(patient_id=patient.patient_id)
+```

pylibrelinkup-0.0.1/README.md

@@ -0,0 +1,42 @@
+# pylibrelinkup
+
+`pylibrelinkup` is a Python client for the LibreLinkUp API, which allows you to interact with the LibreLinkUp service to retrieve glucose data and other related information. This project is a Python implementation inspired by the [libre-link-up-api-client](https://github.com/DiaKEM/libre-link-up-api-client) project.
+
+## Installation
+
+To install `pylibrelinkup`, you can use `pip`:
+
+```bash
+pip install pylibrelinkup
+```
+
+## Usage
+
+### Initialization
+
+First, you need to import the necessary modules, initialize the client, and authenticate with your LibreLinkUp credentials:
+
+```python
+from pylibrelinkup.client import LibreLinkUpClient
+
+client = LibreLinkUpClient(username='your_username', password='your_password')
+client.authenticate()
+```
+
+### Getting Patient List
+
+You can fetch the patient list using the `get_patient_list` method:
+
+```python
+patient_list = client.get_patient_list()
+print(patient_list)
+```
+
+### Getting Patient data
+
+Retrieve patient data using the `get_graph_data` method:
+
+```python
+patient = client.get_patient_list()[0]
+patient_data = client.get_graph_data(patient_id=patient.patient_id)
+```

pylibrelinkup-0.0.1/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pylibrelinkup"
+version = "0.0.1"
+description = "A client for the Abbott LibreLinkUp API"
+readme = "README.md"
+authors = [
+  { name="Rob Berwick", email="rob.berwick@gmail.com" },
+]
+license = { file="LICENSE" }
+keywords = [
+    "librelink",
+    "librelinkup",
+    "abbott",
+    "diabetes",
+    "glucose",
+    "api",
+    "client",
+    "health",
+    "medical",
+    "blood-sugar",
+    "continuous-glucose-monitoring",
+    "cgm"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+  "requests>=2.31.0",
+  "pydantic>= 2.5.0",
+]
+requires-python = ">=3.11"
+
+[project.optional-dependencies]
+dev = ["black"]
+test = ["pytest", "pytest-cov", "pytest-mock", "polyfactory", "responses"]
+
+[project.urls]
+Homepage = "https://github.com/robberwick/pylibrelinkup"
+Issues = "https://github.com/robberwick/pylibrelinkup/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pylibrelinkup-0.0.1/setup.cfg

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

pylibrelinkup-0.0.1/src/pylibrelinkup/api_url.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Type, cast
+
+
+class APIUrl(StrEnum):
+    EU = "https://api-eu.libreview.io"
+    EU2 = "https://api-eu2.libreview.io"
+    US = "https://api.libreview.io"
+
+    @classmethod
+    def from_string(cls: Type[APIUrl], value: str) -> APIUrl:
+        for member in cls:
+            if member.lower() == value.lower():
+                return cast(APIUrl, member)
+        raise ValueError(f"{value} is not a valid {cls.__name__}")

pylibrelinkup-0.0.1/src/pylibrelinkup/client.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from uuid import UUID
+
+import requests
+from pydantic import ValidationError
+
+from .api_url import APIUrl
+from .exceptions import AuthenticationError, RedirectError
+from .models.connection import ConnectionResponse
+from .models.data import Patient
+from .models.login import LoginArgs, LoginResponse
+
+
+class Client:
+    """Client class to request data from the LibreLinkUp API."""
+
+    email: str
+    password: str
+    token: str | None
+
+    HEADERS = {
+        "accept-encoding": "gzip",
+        "cache-control": "no-cache",
+        "connection": "Keep-Alive",
+        "content-type": "application/json",
+        "product": "llu.android",
+        "version": "4.7.0",
+    }
+
+    def __init__(self, email: str, password: str, api_url: APIUrl = APIUrl.US):
+        self.login_args: LoginArgs = LoginArgs(email=email, password=password)
+        self.email = email or ""
+        self.password = password or ""
+        self.token = None
+        self.api_url: str = api_url.value
+
+    def authenticate(self) -> None:
+        r = requests.post(
+            url=f"{self.api_url}/llu/auth/login",
+            headers=self.HEADERS,
+            json=self.login_args.model_dump(),
+        )
+        r.raise_for_status()
+        data = r.json()
+        # Response to login can either be a request to use a different regional host, just successful, or a request
+        # to first accept terms.
+        # Here we handle the first two cases.
+        # TODO: Handle the case where the user needs to accept terms.
+        try:
+            data_dict = data.get("data", {})
+            if data_dict.get("redirect", False):
+                raise RedirectError(APIUrl.from_string(data_dict["region"]))
+            else:
+                login_response = LoginResponse.model_validate(data)
+                self.token = login_response.data.authTicket.token
+                self.HEADERS.update({"authorization": "Bearer " + self.token})
+
+        except ValidationError:
+            raise AuthenticationError("Invalid login credentials")
+
+    def get_patients(self) -> list[Patient]:
+        """Requests and returns patient data"""
+        r = requests.get(url=f"{self.api_url}/llu/connections", headers=self.HEADERS)
+        r.raise_for_status()
+        data = r.json()
+        return [Patient.model_validate(patient) for patient in data["data"]]
+
+    def get_graph_data(self, patient_id: UUID) -> ConnectionResponse:
+        """Requests and returns patient graph data"""
+        r = requests.get(
+            url=f"{self.api_url}/llu/connections/{patient_id}/graph",
+            headers=self.HEADERS,
+        )
+        r.raise_for_status()
+
+        return ConnectionResponse.model_validate(r.json())

pylibrelinkup-0.0.1/src/pylibrelinkup/exceptions.py

@@ -0,0 +1,17 @@
+from .api_url import APIUrl
+
+
+class AuthenticationError(Exception):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class RedirectError(Exception):
+    """Raised when a redirect is encountered during authentication. This is a signal to retry the request with the new region.
+    The new region is stored in the `region` attribute of the exception, which is an APIUrl enum value.
+    """
+
+    def __init__(self, region: APIUrl):
+        self.region = region
+        super().__init__(f"Redirected to {region}")

pylibrelinkup-0.0.1/src/pylibrelinkup/models/config.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+from pylibrelinkup.models.data import H, F, Nd, Std, L
+
+
+class AlarmRules(BaseModel):
+    """AlarmRules class to store alarm rules data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    c: bool
+    h: H
+    f: F
+    l: L
+    nd: Nd
+    p: int
+    r: int
+    std: Std
+
+
+class FixedLowAlarmValues(BaseModel):
+    """FixedLowAlarmValues class to store fixed alarm values."""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    mgdl: int
+    mmoll: float

pylibrelinkup-0.0.1/src/pylibrelinkup/models/connection.py

@@ -0,0 +1,85 @@
+from uuid import UUID
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+)
+from pydantic.alias_generators import to_camel
+
+from .config import AlarmRules
+from .data import GlucoseItem
+from .hardware import Sensor, PatientDevice, ActiveSensor
+
+
+class Connection(BaseModel):
+    """Connection class to store connection data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    id: UUID
+    patient_id: UUID
+    country: str
+    status: int
+    first_name: str
+    last_name: str
+    target_low: int
+    target_high: int
+    uom: int
+    sensor: Sensor
+    alarm_rules: AlarmRules
+    glucose_measurement: GlucoseItem
+    glucose_item: GlucoseItem
+    glucose_alarm: None
+    patient_device: PatientDevice
+    created: int
+
+
+class Data(BaseModel):
+    """Data class to store connection data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    connection: Connection
+    active_sensors: list[ActiveSensor] = Field(alias="activeSensors")
+    graph_data: list[GlucoseItem] = Field(alias="graphData")
+
+
+class Ticket(BaseModel):
+    """TicketData class to store ticket data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    token: str
+    expires: int
+    duration: int
+
+
+class ConnectionResponse(BaseModel):
+    """ConnectionResponse class to store API connection endpoint response."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    status: int
+    data: Data
+    ticket: Ticket

pylibrelinkup-0.0.1/src/pylibrelinkup/models/data.py

@@ -0,0 +1,145 @@
+from datetime import datetime, UTC
+from enum import IntEnum
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic.alias_generators import to_camel, to_pascal
+from pydantic_core.core_schema import ValidationInfo
+
+
+class Patient(BaseModel):
+    """Patient class to store patient data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    id: UUID
+    patient_id: UUID
+    first_name: str
+    last_name: str
+
+    def __str__(self):
+        return f"{self.first_name} {self.last_name}: {self.id}"
+
+
+class Trend(IntEnum):
+    DOWN_FAST: int = 1
+    DOWN_SLOW: int = 2
+    STABLE: int = 3
+    UP_SLOW: int = 4
+    UP_FAST: int = 5
+
+
+class GlucoseItem(BaseModel):
+    """GlucoseMeasurement class to store glucose measurement data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_pascal,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    factory_timestamp: datetime = Field(None)
+    timestamp: datetime = Field(None)
+    type: int
+    value_in_mg_per_dl: float
+    measurement_color: int
+    glucose_units: int
+    value: float
+    is_high: bool = Field(alias="isHigh")
+    is_low: bool = Field(alias="isLow")
+
+    def __str__(self):
+        return f"{self.timestamp}: {self.value}"
+
+    @field_validator("timestamp", "factory_timestamp", mode="before")
+    @classmethod
+    def parse_timestamp(cls, v: str, info: ValidationInfo):
+        if isinstance(v, str):
+            datetime_value = datetime.strptime(v, "%m/%d/%Y %I:%M:%S %p")
+        elif isinstance(v, datetime):
+            datetime_value = v
+        else:
+            raise ValueError(
+                f"Invalid type for {info.field_name}: {type(v)}. Expected str or datetime."
+            )
+
+        if info.field_name == "factory_timestamp":
+            # factory_timestamp is in UTC
+            datetime_value = datetime_value.replace(tzinfo=UTC)
+        return datetime_value
+
+
+class GlucoseItemTrend(GlucoseItem):
+    trend_arrow: Trend
+
+    def __str__(self):
+        return f"{super().__str__()} {self.trend_arrow}"
+
+
+class F(BaseModel):
+    """F class to store F data."""
+
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+
+    th: int
+    thmm: float
+    d: int
+    tl: int
+    tlmm: float
+
+
+class L(BaseModel):
+    """L class to store L data."""
+
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+
+    th: int
+    thmm: float
+    d: int
+    tl: int
+    tlmm: float
+
+
+class H(BaseModel):
+    """H class to store H data."""
+
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+
+    th: int
+    thmm: float
+    d: int
+    f: float
+
+
+class Nd(BaseModel):
+    """Nd class to store Nd data."""
+
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+
+    i: int
+    r: int
+    l: int
+
+
+class Std(BaseModel):
+    """Std class to store Std data."""
+
+    ...
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+    sd: bool

pylibrelinkup-0.0.1/src/pylibrelinkup/models/hardware.py

@@ -0,0 +1,55 @@
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+from .config import FixedLowAlarmValues
+
+
+class Sensor(BaseModel):
+    """Sensor class to store sensor data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    device_id: str
+    sn: str
+    a: int
+    w: int
+    pt: int
+
+
+class PatientDevice(BaseModel):
+    """PatientDevice class to store device data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    did: str
+    dtid: int
+    v: str
+    ll: int
+    hl: int
+    u: int
+    fixed_low_alarm_values: FixedLowAlarmValues
+    alarms: bool
+
+
+class ActiveSensor(BaseModel):
+    """ActiveSensor class to store active sensor data."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    sensor: Sensor
+    device: PatientDevice

pylibrelinkup-0.0.1/src/pylibrelinkup/models/login.py

@@ -0,0 +1,100 @@
+from typing import List
+
+from pydantic import BaseModel
+
+
+class Llu(BaseModel):
+    policyAccept: int
+    touAccept: int
+
+
+class Consents(BaseModel):
+    llu: Llu
+
+
+class SystemMessages(BaseModel):
+    firstUsePhoenix: int
+    firstUsePhoenixReportsDataMerged: int
+    lluGettingStartedBanner: int
+    lluNewFeatureModal: int
+    lluOnboarding: int
+    lvWebPostRelease: str
+
+
+class System(BaseModel):
+    messages: SystemMessages
+
+
+class User(BaseModel):
+    id: str
+    firstName: str
+    lastName: str
+    email: str
+    country: str
+    uiLanguage: str
+    communicationLanguage: str
+    accountType: str
+    uom: str
+    dateFormat: str
+    timeFormat: str
+    emailDay: List[int]
+    system: System
+    details: dict
+    created: int
+    lastLogin: int
+    programs: dict
+    dateOfBirth: int
+    practices: dict
+    devices: dict
+    consents: Consents
+
+
+class Notifications(BaseModel):
+    unresolved: int
+
+
+class DataMessages(BaseModel):
+    unread: int
+
+
+class AuthTicket(BaseModel):
+    token: str
+    expires: int
+    duration: int
+
+
+class Data(BaseModel):
+    user: User
+    messages: DataMessages
+    notifications: Notifications
+    authTicket: AuthTicket
+    invitations: List[str]
+
+
+class LoginResponse(BaseModel):
+    status: int
+    data: Data
+
+
+class ErrorMessage(BaseModel):
+    message: str
+
+
+class LoginResponseUnauthenticated(BaseModel):
+    status: int
+    error: ErrorMessage
+
+
+class LoginRedirectData(BaseModel):
+    redirect: bool
+    region: str
+
+
+class LoginRedirectResponse(BaseModel):
+    status: int
+    data: LoginRedirectData
+
+
+class LoginArgs(BaseModel):
+    email: str = ""
+    password: str = ""

pylibrelinkup-0.0.1/src/pylibrelinkup.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.1
+Name: pylibrelinkup
+Version: 0.0.1
+Summary: A client for the Abbott LibreLinkUp API
+Author-email: Rob Berwick <rob.berwick@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Rob Berwick
+        
+        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/robberwick/pylibrelinkup
+Project-URL: Issues, https://github.com/robberwick/pylibrelinkup/issues
+Keywords: librelink,librelinkup,abbott,diabetes,glucose,api,client,health,medical,blood-sugar,continuous-glucose-monitoring,cgm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pydantic>=2.5.0
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: polyfactory; extra == "test"
+Requires-Dist: responses; extra == "test"
+
+# pylibrelinkup
+
+`pylibrelinkup` is a Python client for the LibreLinkUp API, which allows you to interact with the LibreLinkUp service to retrieve glucose data and other related information. This project is a Python implementation inspired by the [libre-link-up-api-client](https://github.com/DiaKEM/libre-link-up-api-client) project.
+
+## Installation
+
+To install `pylibrelinkup`, you can use `pip`:
+
+```bash
+pip install pylibrelinkup
+```
+
+## Usage
+
+### Initialization
+
+First, you need to import the necessary modules, initialize the client, and authenticate with your LibreLinkUp credentials:
+
+```python
+from pylibrelinkup.client import LibreLinkUpClient
+
+client = LibreLinkUpClient(username='your_username', password='your_password')
+client.authenticate()
+```
+
+### Getting Patient List
+
+You can fetch the patient list using the `get_patient_list` method:
+
+```python
+patient_list = client.get_patient_list()
+print(patient_list)
+```
+
+### Getting Patient data
+
+Retrieve patient data using the `get_graph_data` method:
+
+```python
+patient = client.get_patient_list()[0]
+patient_data = client.get_graph_data(patient_id=patient.patient_id)
+```

pylibrelinkup-0.0.1/src/pylibrelinkup.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/pylibrelinkup/__init__.py
+src/pylibrelinkup/api_url.py
+src/pylibrelinkup/client.py
+src/pylibrelinkup/exceptions.py
+src/pylibrelinkup.egg-info/PKG-INFO
+src/pylibrelinkup.egg-info/SOURCES.txt
+src/pylibrelinkup.egg-info/dependency_links.txt
+src/pylibrelinkup.egg-info/requires.txt
+src/pylibrelinkup.egg-info/top_level.txt
+src/pylibrelinkup/models/__init__.py
+src/pylibrelinkup/models/config.py
+src/pylibrelinkup/models/connection.py
+src/pylibrelinkup/models/data.py
+src/pylibrelinkup/models/hardware.py
+src/pylibrelinkup/models/login.py
+tests/test_client_authentication.py

pylibrelinkup-0.0.1/src/pylibrelinkup.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pylibrelinkup-0.0.1/src/pylibrelinkup.egg-info/requires.txt

@@ -0,0 +1,12 @@
+requests>=2.31.0
+pydantic>=2.5.0
+
+[dev]
+black
+
+[test]
+pytest
+pytest-cov
+pytest-mock
+polyfactory
+responses

pylibrelinkup-0.0.1/src/pylibrelinkup.egg-info/top_level.txt

@@ -0,0 +1 @@
+pylibrelinkup

pylibrelinkup-0.0.1/tests/test_client_authentication.py

@@ -0,0 +1,105 @@
+import json
+
+import pytest
+import requests
+import responses
+from polyfactory.factories.pydantic_factory import ModelFactory
+
+from pylibrelinkup.client import Client, AuthenticationError
+from pylibrelinkup.api_url import APIUrl
+from pylibrelinkup.models.connection import ConnectionResponse
+from pylibrelinkup.models.data import Patient
+from pylibrelinkup.models.login import (
+    LoginResponse,
+)
+
+
+class LoginResponseFactory(ModelFactory[LoginResponse]):
+    __model__ = LoginResponse
+
+
+class ConnectionResponseFactory(ModelFactory[ConnectionResponse]):
+    __model__ = ConnectionResponse
+
+
+class PatientFactory(ModelFactory[Patient]):
+    __model__ = Patient
+
+
+@pytest.fixture
+def mocked_responses():
+    with responses.RequestsMock() as rsps:
+        yield rsps
+
+
+@pytest.mark.parametrize("api_url", APIUrl)
+def test_authenticate_raises_error_on_incorrect_login(
+    mocked_responses, api_url: APIUrl
+):
+    """Test that the authenticate method raises an error when the login fails."""
+    mocked_responses.add(
+        responses.POST,
+        f"{api_url.value}/llu/auth/login",
+        json={"not": "important"},
+        status=200,
+    )
+
+    client = Client(email="parp", password="parp", api_url=api_url)
+
+    with pytest.raises(AuthenticationError):
+        client.authenticate()
+
+
+@pytest.mark.parametrize("api_url", APIUrl)
+def test_authenticate_sets_token_on_correct_login(mocked_responses, api_url: APIUrl):
+    """Test that the authenticate method sets the token on a successful login."""
+    response = LoginResponseFactory.build()
+    response.data.authTicket.token = "parp"
+    assert isinstance(response, LoginResponse)
+
+    mocked_responses.add(
+        responses.POST,
+        f"{api_url.value}/llu/auth/login",
+        json=json.loads(response.model_dump_json()),
+        status=200,
+    )
+
+    client = Client(email="parp", password="parp", api_url=api_url)
+
+    client.authenticate()
+
+    assert client.token == "parp"
+
+
+@pytest.mark.parametrize("api_url", APIUrl)
+def test_authenticate_raises_error_on_invalid_response(
+    mocked_responses, api_url: APIUrl
+):
+    """Test that the authenticate method raises an error on invalid response."""
+    mocked_responses.add(
+        responses.POST,
+        f"{api_url.value}/llu/auth/login",
+        json={"invalid": "response"},
+        status=200,
+    )
+
+    client = Client(email="parp", password="parp", api_url=api_url)
+
+    with pytest.raises(AuthenticationError):
+        client.authenticate()
+
+
+@pytest.mark.parametrize("api_url", APIUrl)
+def test_authenticate_raises_error_on_http_error(mocked_responses, api_url: APIUrl):
+    """Test that the authenticate method raises an error on HTTP error."""
+    mocked_responses.add(
+        responses.POST,
+        f"{api_url.value}/llu/auth/login",
+        json={"error": "Unauthorized"},
+        status=401,
+    )
+
+    client = Client(email="parp", password="parp", api_url=api_url)
+
+    with pytest.raises(requests.exceptions.HTTPError):
+        client.authenticate()