otf-api 0.2.0__tar.gz

otf_api-0.2.0/AUTHORS.md

@@ -0,0 +1,9 @@
+# Credits
+
+## Development Lead
+
+* Jessica Smith <j.smith.git1@gmail.com>
+
+## Contributors
+
+None yet. Why not be the first?

otf_api-0.2.0/LICENSE

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

otf_api-0.2.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: otf-api
+Version: 0.2.0
+Summary: Python OrangeTheory Fitness API Client
+License: MIT
+Author: Jessica Smith
+Author-email: j.smith.git1@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: aiohttp (==3.9.5)
+Requires-Dist: loguru (==0.7.2)
+Requires-Dist: pycognito (==2024.5.1)
+Requires-Dist: pydantic (==2.7.3)
+Description-Content-Type: text/markdown
+
+Simple API client for interacting with the OrangeTheory APIs. This project is in now way affiliated with OrangeTheory Fitness.
+

otf_api-0.2.0/README.md

@@ -0,0 +1 @@
+Simple API client for interacting with the OrangeTheory APIs. This project is in now way affiliated with OrangeTheory Fitness.

otf_api-0.2.0/pyproject.toml

@@ -0,0 +1,70 @@
+[tool.poetry]
+name = "otf-api"
+version = "0.2.0"
+description = "Python OrangeTheory Fitness API Client"
+authors = ["Jessica Smith <j.smith.git1@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Internet :: WWW/HTTP",
+    "Operating System :: OS Independent",
+]
+
+
+[tool.poetry.dependencies]
+python = "^3.10"
+aiohttp = "3.9.5"
+loguru = "0.7.2"
+pydantic = "2.7.3"
+pycognito = "2024.5.1"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "8.2.2"
+pytest-loguru = "0.4.0"
+pytest-asyncio = "0.23.7"
+aioresponses = "0.7.6"
+tox = "4.15.1"
+pytest-cov = "5.0.0"
+build = "1.2.1"
+ruff = "0.4.9"
+pre-commit = "3.7.1"
+mypy = "1.10.0"
+twine = "5.1.0"
+black = "^24.4.2"
+httpx = "^0.27.0"
+bump-my-version = "^0.23.0"
+
+
+[tool.poetry.group.docs.dependencies]
+mkdocs = "1.6.0"
+mkdocs-autorefs = "1.0.1"
+mkdocs-gen-files = "0.5.0"
+mkdocs-get-deps = "0.2.0"
+mkdocs-include-markdown-plugin = "6.2.0"
+mkdocs-literate-nav = "0.6.1"
+mkdocs-material = "9.5.26"
+mkdocs-material-extensions = "1.3.1"
+mkdocs-section-index = "0.3.9"
+mkdocstrings = "0.25.1"
+mkdocstrings-python = "1.10.3"
+griffe-fieldz = "0.1.2"
+mike = "2.1.1"
+setuptools = "^70.0.0"
+pkginfo = "^1.11.1"
+virtualenv = "^20.26.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tools.pytest.ini_options]
+pythonpath = ["src"]

otf_api-0.2.0/src/otf_api/__init__.py

@@ -0,0 +1,70 @@
+from . import classes_api, member_api, studios_api, telemetry_api
+from .api import Api
+from .models.auth import User
+from .models.responses import (
+    ALL_CLASS_STATUS,
+    ALL_HISTORY_CLASS_STATUS,
+    ALL_STUDIO_STATUS,
+    BookingList,
+    BookingStatus,
+    ChallengeTrackerContent,
+    ChallengeTrackerDetailList,
+    ChallengeType,
+    EquipmentType,
+    FavoriteStudioList,
+    HistoryClassStatus,
+    LatestAgreement,
+    MemberDetail,
+    MemberMembership,
+    MemberPurchaseList,
+    OtfClassList,
+    OutOfStudioWorkoutHistoryList,
+    PerformanceSummaryDetail,
+    PerformanceSummaryList,
+    StudioDetail,
+    StudioDetailList,
+    StudioServiceList,
+    StudioStatus,
+    Telemetry,
+    TelemetryHrHistory,
+    TelemetryMaxHr,
+    TotalClasses,
+    WorkoutList,
+)
+
+__all__ = [
+    "Api",
+    "User",
+    "member_api",
+    "BookingList",
+    "ChallengeTrackerContent",
+    "ChallengeTrackerDetailList",
+    "ChallengeType",
+    "BookingStatus",
+    "EquipmentType",
+    "HistoryClassStatus",
+    "LatestAgreement",
+    "MemberDetail",
+    "MemberMembership",
+    "MemberPurchaseList",
+    "OutOfStudioWorkoutHistoryList",
+    "StudioServiceList",
+    "StudioStatus",
+    "TotalClasses",
+    "WorkoutList",
+    "FavoriteStudioList",
+    "OtfClassList",
+    "classes_api",
+    "studios_api",
+    "telemetry_api",
+    "TelemetryHrHistory",
+    "Telemetry",
+    "TelemetryMaxHr",
+    "StudioDetail",
+    "StudioDetailList",
+    "ALL_CLASS_STATUS",
+    "ALL_HISTORY_CLASS_STATUS",
+    "ALL_STUDIO_STATUS",
+    "PerformanceSummaryDetail",
+    "PerformanceSummaryList",
+]

otf_api-0.2.0/src/otf_api/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

otf_api-0.2.0/src/otf_api/api.py

@@ -0,0 +1,143 @@
+import asyncio
+import typing
+from typing import Any
+
+import aiohttp
+from loguru import logger
+from yarl import URL
+
+from otf_api.classes_api import ClassesApi
+from otf_api.member_api import MemberApi
+from otf_api.models.auth import User
+from otf_api.performance_api import PerformanceApi
+from otf_api.studios_api import StudiosApi
+from otf_api.telemetry_api import TelemtryApi
+
+if typing.TYPE_CHECKING:
+    from loguru import Logger
+
+    from otf_api.models.responses.member_detail import MemberDetail
+    from otf_api.models.responses.studio_detail import StudioDetail
+
+API_BASE_URL = "api.orangetheory.co"
+API_IO_BASE_URL = "api.orangetheory.io"
+API_TELEMETRY_BASE_URL = "api.yuzu.orangetheory.com"
+REQUEST_HEADERS = {"Authorization": None, "Content-Type": "application/json", "Accept": "application/json"}
+
+
+class Api:
+    """The main class of the otf-api library. Create an instance using the async method `create`.
+
+    Example:
+        ---
+        ```python
+        import asyncio
+        from otf_api import Api
+
+        async def main():
+            otf = await Api.create("username", "password")
+            print(otf.member)
+
+        if __name__ == "__main__":
+            asyncio.run(main())
+        ```
+    """
+
+    logger: "Logger" = logger
+    user: User
+    session: aiohttp.ClientSession
+
+    def __init__(self, username: str, password: str):
+        self.member: MemberDetail
+        self.home_studio: StudioDetail
+
+        self.user = User.load_from_disk(username, password)
+        self.session = aiohttp.ClientSession()
+
+        self.member_api = MemberApi(self)
+        self.classes_api = ClassesApi(self)
+        self.studios_api = StudiosApi(self)
+        self.telemetry_api = TelemtryApi(self)
+        self.performance_api = PerformanceApi(self)
+
+    @classmethod
+    async def create(cls, username: str, password: str) -> "Api":
+        """Create a new API instance. The username and password are required arguments because even though
+        we cache the token, they expire so quickly that we usually end up needing to re-authenticate.
+
+        Args:
+            username (str): The username of the user.
+            password (str): The password of the user.
+        """
+        self = cls(username, password)
+        self.member = await self.member_api.get_member_detail()
+        self.home_studio = await self.studios_api.get_studio_detail(self.member.home_studio.studio_uuid)
+        return self
+
+    def __del__(self) -> None:
+        try:
+            loop = asyncio.get_event_loop()
+            asyncio.create_task(self._close_session())  # noqa
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            loop.run_until_complete(self._close_session())
+
+    async def _close_session(self) -> None:
+        if not self.session.closed:
+            await self.session.close()
+
+    @property
+    def _base_headers(self) -> dict[str, str]:
+        """Get the base headers for the API."""
+        if not self.user:
+            raise ValueError("No user is logged in.")
+
+        return {
+            "Authorization": f"Bearer {self.user.cognito.id_token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+    async def _do(
+        self,
+        method: str,
+        base_url: str,
+        url: str,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        """Perform an API request."""
+
+        params = params or {}
+        params = {k: v for k, v in params.items() if v is not None}
+
+        full_url = str(URL.build(scheme="https", host=base_url, path=url))
+
+        logger.debug(f"Making {method!r} request to {full_url}, params: {params}")
+
+        if headers:
+            headers.update(self._base_headers)
+        else:
+            headers = self._base_headers
+
+        async with self.session.request(method, full_url, headers=headers, params=params) as response:
+            response.raise_for_status()
+            return await response.json()
+
+    async def _classes_request(self, method: str, url: str, params: dict[str, Any] | None = None) -> Any:
+        """Perform an API request to the classes API."""
+        return await self._do(method, API_IO_BASE_URL, url, params)
+
+    async def _default_request(self, method: str, url: str, params: dict[str, Any] | None = None) -> Any:
+        """Perform an API request to the default API."""
+        return await self._do(method, API_BASE_URL, url, params)
+
+    async def _telemetry_request(self, method: str, url: str, params: dict[str, Any] | None = None) -> Any:
+        """Perform an API request to the Telemetry API."""
+        return await self._do(method, API_TELEMETRY_BASE_URL, url, params)
+
+    async def _performance_summary_request(
+        self, method: str, url: str, headers: dict[str, str], params: dict[str, Any] | None = None
+    ) -> Any:
+        """Perform an API request to the performance summary API."""
+        return await self._do(method, API_IO_BASE_URL, url, params, headers)

otf_api-0.2.0/src/otf_api/classes_api.py

@@ -0,0 +1,44 @@
+import typing
+
+from otf_api.models.responses.classes import OtfClassList
+
+if typing.TYPE_CHECKING:
+    from otf_api import Api
+
+
+class ClassesApi:
+    def __init__(self, api: "Api"):
+        self._api = api
+        self.logger = api.logger
+
+        # simplify access to member_id and member_uuid
+        self._member_id = self._api.user.member_id
+        self._member_uuid = self._api.user.member_uuid
+
+    async def get_classes(
+        self, studio_uuids: list[str] | None = None, include_home_studio: bool = True
+    ) -> OtfClassList:
+        """Get the classes for the user.
+
+        Returns a list of classes that are available for the user, based on the studio UUIDs provided. If no studio
+        UUIDs are provided, it will default to the user's home studio.
+
+        Args:
+            studio_uuids (list[str] | None): The studio UUIDs to get the classes for. Default is None, which will\
+            default to the user's home studio only.
+            include_home_studio (bool): Whether to include the home studio in the classes. Default is True.
+
+        Returns:
+            OtfClassList: The classes for the user.
+        """
+
+        if not studio_uuids:
+            studio_uuids = [self._api.home_studio.studio_uuid]
+        elif include_home_studio and self._api.home_studio.studio_uuid not in studio_uuids:
+            studio_uuids.append(self._api.home_studio.studio_uuid)
+
+        path = "/v1/classes"
+
+        params = {"studio_ids": studio_uuids}
+        res = await self._api._classes_request("GET", path, params=params)
+        return OtfClassList(classes=res["items"])