brightcove-async 0.1.0__tar.gz

brightcove_async-0.1.0/LICENSE.txt

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

brightcove_async-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: brightcove_async
+Version: 0.1.0
+Summary: An asynchronous client for the Brightcove API.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: aiohttp>=3.12.14
+Requires-Dist: aiolimiter>=1.2.1
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: tenacity>=9.1.2
+Dynamic: license-file

brightcove_async-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "brightcove_async"
+version = "0.1.0"
+description = "An asynchronous client for the Brightcove API."
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "aiohttp>=3.12.14",
+    "aiolimiter>=1.2.1",
+    "pydantic>=2.11.7",
+    "pydantic-settings>=2.10.1",
+    "tenacity>=9.1.2",
+]
+
+
+[dependency-groups]
+dev = [
+    "datamodel-code-generator>=0.31.2",
+    "mypy>=1.17.0",
+    "pre-commit>=4.2.0",
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.1.0",
+]
+
+[tool.mypy]
+plugins = [
+  "pydantic.mypy"
+]
+
+[tool.uv]
+package = true

brightcove_async-0.1.0/setup.cfg

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

brightcove_async-0.1.0/src/brightcove_async/__init__.py

@@ -0,0 +1,4 @@
+from .initalise import initialise_brightcove_client
+from .client import BrightcoveClient
+
+__all__ = ["initialise_brightcove_client", "BrightcoveClient"]

brightcove_async-0.1.0/src/brightcove_async/client.py

@@ -0,0 +1,92 @@
+from typing import ClassVar, Self, cast
+
+import aiohttp
+
+from brightcove_async.protocols import OAuthClientProtocol
+from brightcove_async.services.analytics import Analytics
+from brightcove_async.services.base import Base
+from brightcove_async.services.cms import CMS
+from brightcove_async.services.syndication import Syndication
+
+
+class BrightcoveClient:
+    _service_classes: ClassVar[dict[str, type[Base]]] = {
+        "cms": CMS,
+        "syndication": Syndication,
+        "analytics": Analytics,
+    }
+
+    def __init__(
+        self,
+        cms_base_url: str,
+        syndication_base_url: str,
+        analytics_base_url: str,
+        client_id: str,
+        client_secret: str,
+        oauth_cls: type[OAuthClientProtocol],
+        session: aiohttp.ClientSession | None = None,
+    ) -> None:
+        self._oauth_cls = oauth_cls
+        self._cms_base_url = cms_base_url
+        self._syndication_base_url = syndication_base_url
+        self._analytics_base_url = analytics_base_url
+        self._session: aiohttp.ClientSession | None = session
+        self._external_session = session
+        self._oauth: OAuthClientProtocol | None = None
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._services: dict[str, Base] = {}
+
+    @property
+    def oauth(self) -> OAuthClientProtocol:
+        if self._session is None:
+            raise RuntimeError(
+                "Client session not initialized. Use as an async context manager."
+            )
+        if self._oauth is None:
+            self._oauth = self._oauth_cls(
+                client_id=self._client_id,
+                client_secret=self._client_secret,
+                session=self._session,
+            )
+        return self._oauth
+
+    def _get_service(self, name: str, base_url: str) -> Base:
+        if name not in self._services:
+            service_cls = self._service_classes[name]
+            if self._session is None:
+                raise RuntimeError(
+                    "Client session not initialized. Use as an async context manager."
+                )
+            self._services[name] = service_cls(self._session, self.oauth, base_url)
+        return self._services[name]
+
+    @property
+    def cms(self) -> CMS:
+        return cast("CMS", self._get_service("cms", self._cms_base_url))
+
+    @property
+    def syndication(self) -> Syndication:
+        return cast(
+            "Syndication", self._get_service("syndication", self._syndication_base_url)
+        )
+
+    @property
+    def analytics(self) -> Analytics:
+        return cast(
+            "Analytics", self._get_service("analytics", self._analytics_base_url)
+        )
+
+    async def __aenter__(self) -> Self:
+        if self._session is None:
+            self._session = aiohttp.ClientSession(
+                connector=aiohttp.TCPConnector(limit=100)
+            )
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        if self._session and not self._external_session:
+            await self._session.close()
+            self._session = None
+        self._services.clear()
+        self._oauth = None

brightcove_async-0.1.0/src/brightcove_async/initalise.py

@@ -0,0 +1,26 @@
+from brightcove_async.client import BrightcoveClient
+from brightcove_async.oauth.oauth import OAuthClient
+from brightcove_async.settings import BrightcoveBaseAPIConfig, BrightcoveOAuthCreds
+
+
+def initialise_brightcove_client(
+    oauth_creds: BrightcoveOAuthCreds | None = None,
+    client_config: BrightcoveBaseAPIConfig | None = None,
+) -> BrightcoveClient:
+    """Initialise the Brightcove client with OAuth credentials.
+    Returns the configured OAuthClient.
+    """
+    client_credentials = BrightcoveOAuthCreds() if oauth_creds is None else oauth_creds  # type: ignore[ReportCallIssueType]
+
+    client_config = (
+        BrightcoveBaseAPIConfig() if client_config is None else client_config
+    )  # type: ignore[ReportCallIssueType]
+
+    return BrightcoveClient(
+        client_id=client_credentials.client_id,
+        client_secret=client_credentials.client_secret.get_secret_value(),
+        oauth_cls=OAuthClient,
+        cms_base_url=client_config.cms_base_url,
+        syndication_base_url=client_config.syndication_base_url,
+        analytics_base_url=client_config.analytics_base_url,
+    )

brightcove_async-0.1.0/src/brightcove_async/oauth/oauth.py

@@ -0,0 +1,69 @@
+import time
+
+import aiohttp
+from aiohttp import BasicAuth
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+
+class OAuthClient:
+    base_url = "https://oauth.brightcove.com/v4/access_token"
+
+    def __init__(
+        self, client_id: str, client_secret: str, session: aiohttp.ClientSession
+    ) -> None:
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self._access_token: str | None = None
+        self._request_time = 0.0
+        self._token_life = 240.0  # Token expires after 4 minutes
+        self._session: aiohttp.ClientSession = session
+
+    @retry(
+        retry=retry_if_exception_type(
+            (aiohttp.ClientConnectionError),
+        ),
+        wait=wait_exponential(multiplier=1, min=1, max=3),  # exponential backoff
+        stop=stop_after_attempt(3),  # up to 5 retries
+    )
+    async def _get_access_token(self) -> None:
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        data = {"grant_type": "client_credentials"}
+
+        async with (
+            self._session.post(
+                url=self.base_url,
+                headers=headers,
+                data=data,
+                auth=BasicAuth(self.client_id, self.client_secret),
+                timeout=aiohttp.ClientTimeout(total=10),
+            ) as response,
+        ):
+            response.raise_for_status()
+            json_data = await response.json()
+            self._access_token = json_data.get("access_token")
+            self._request_time = time.time()
+
+    async def get_access_token(self) -> str:
+        if (
+            not self._access_token
+            or time.time() - self._request_time > self._token_life
+        ):
+            await self._get_access_token()
+
+        if not self._access_token:
+            raise ValueError("Failed to fetch access token.")
+
+        return self._access_token
+
+    @property
+    async def headers(self) -> dict[str, str]:
+        access_token = await self.get_access_token()
+        return {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json",
+        }

brightcove_async-0.1.0/src/brightcove_async/protocols.py

@@ -0,0 +1,15 @@
+from typing import Protocol, runtime_checkable
+
+import aiohttp
+
+
+@runtime_checkable
+class OAuthClientProtocol(Protocol):
+    def __init__(
+        self, client_id: str, client_secret: str, session: aiohttp.ClientSession
+    ) -> None: ...
+
+    async def get_access_token(self) -> str: ...
+
+    @property
+    async def headers(self) -> dict[str, str]: ...

brightcove_async-0.1.0/src/brightcove_async/schemas/analytics_model/alltime_videos.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class AllTimeVideoAnalyticsResponse(BaseModel):
+    alltime_video_views: int = 0

brightcove_async-0.1.0/src/brightcove_async/schemas/cms_model/Image.py

@@ -0,0 +1,11 @@
+# generated by datamodel-codegen:
+#   filename:  cms.yaml
+#   timestamp: 2025-07-18T07:27:42+00:00
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class Sources(BaseModel):
+    src: str = Field(..., description="URL for a image source image")

brightcove_async-0.1.0/src/brightcove_async/schemas/cms_model/Videofields.py

@@ -0,0 +1,40 @@
+# generated by datamodel-codegen:
+#   filename:  cms.yaml
+#   timestamp: 2025-07-18T07:27:42+00:00
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class CustomField(BaseModel):
+    description: Optional[str] = Field(
+        None, description="description (instruction for user)"
+    )
+    display_name: Optional[str] = Field(None, description="display name")
+    enum_values: Optional[List[str]] = Field(
+        None, description="array of string values for select type fields"
+    )
+    id: Optional[str] = Field(
+        None,
+        description="data name for the field (used to access it in searches, etc.)",
+    )
+    required: Optional[bool] = Field(
+        False, description="whether field must have a value before video can be active"
+    )
+    type: Optional[str] = Field(None, description="custom field type (enum or string)")
+
+
+class StandardField(BaseModel):
+    description: Optional[str] = Field(
+        None, description="description (instruction for user)"
+    )
+    id: Optional[str] = Field(
+        None,
+        description="data name for the field (used to access it in searches, etc.)",
+    )
+    required: Optional[bool] = Field(
+        None, description="whether field must have a value before video can be active"
+    )