mediaviz-sdk 1.0.5.81.dev0__tar.gz

mediaviz_sdk-1.0.5.81.dev0/LICENSE

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

mediaviz_sdk-1.0.5.81.dev0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mediaviz-sdk
+Version: 1.0.5.81.dev0
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Dynamic: license-file

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/__init__.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from .client import MediaVizClient
+from .errors import ApiError, ValidationError, NotFoundError, RateLimitError, ServerError
+from oauth_sdk import OAuthClient, OAuthError, AuthenticatedResponse, AuthorizationUrlResult, ClientRegistrationRequest, ClientRegistrationResponse, OAuthClientConfig, OAuthErrorCode, TokenPayload, TokenResponse
+
+__all__ = [
+    'MediaVizClient',
+    'ApiError', 'ValidationError', 'NotFoundError', 'RateLimitError', 'ServerError',
+    'OAuthClient',
+    'OAuthError',
+    'AuthenticatedResponse',
+    'AuthorizationUrlResult',
+    'ClientRegistrationRequest',
+    'ClientRegistrationResponse',
+    'OAuthClientConfig',
+    'OAuthErrorCode',
+    'TokenPayload',
+    'TokenResponse',
+]

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/admin.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import Any
+from urllib.parse import quote, urlencode
+import httpx
+
+from .errors import handle_response
+
+
+class Admin:
+    def __init__(self, ctx) -> None:
+        self._ctx = ctx
+
+    def get_category_labels(self, category: str) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/admin/category_labels/' + quote(str(category), safe='')
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/ai_model_credits.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import Any
+from urllib.parse import quote, urlencode
+import httpx
+
+from .errors import handle_response
+
+
+class AiModelCredits:
+    def __init__(self, ctx) -> None:
+        self._ctx = ctx
+
+    def get_model_credit_relationship(self, model_name: str) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/model_credit/' + quote(str(model_name), safe='')
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/client.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+import os
+from typing import Any
+
+from oauth_sdk import OAuthClient, OAuthClientConfig
+from .admin import Admin
+from .ai_model_credits import AiModelCredits
+from .company import Company
+from .curated_albums import CuratedAlbums
+from .custom_albums import CustomAlbums
+from .email_tokens import EmailTokens
+from .health import Health
+from .keywords import Keywords
+from .o_auth_authorization import OAuthAuthorization
+from .o_auth_token import OAuthToken
+from .oauth_login import OauthLogin
+from .person import Person
+from .photo_upload import PhotoUpload
+from .photos import Photos
+from .projects import Projects
+from .search import Search
+from .users import Users
+
+
+class _Context:
+    def __init__(self, mv: "MediaVizClient") -> None:
+        self._mv = mv
+        self.client = mv._tracking_client
+
+    @property
+    def access_token(self) -> str | None: return self._mv._access_token
+    @property
+    def refresh_token(self) -> str | None: return self._mv._refresh_token
+    @property
+    def base_url(self) -> str: return self._mv._config['base_url']
+
+    def require_host(self, key: str) -> str:
+        url = self._mv._hosts.get(key)
+        if url is None:
+            raise RuntimeError(f"Host '{key}' not configured.")
+        return url
+
+    def require_tokens(self) -> None:
+        if self._mv._access_token is None:
+            raise RuntimeError(
+                'Not authenticated. Call authenticate(), handle_callback(), or set_tokens() first.'
+            )
+
+
+class _TokenTrackingClient:
+    def __init__(self, mv: "MediaVizClient", inner: Any) -> None:
+        self._mv = mv
+        self._inner = inner
+
+    def request(self, url: str, method: str, access_token: str, refresh_token: str, body: Any = None) -> Any:
+        def _on_refresh_success(new_tokens: Any) -> None:
+            self._mv.set_tokens(new_tokens.access_token, new_tokens.refresh_token)
+            if self._mv._on_token_refresh:
+                self._mv._on_token_refresh(new_tokens)
+        return self._inner.request(
+            url, method, access_token, refresh_token, body,
+            on_refresh_success=_on_refresh_success,
+        )
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._inner, name)
+
+
+class MediaVizClient:
+    def __init__(
+        self,
+        *,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        base_url: str | None = None,
+        redirect_uri: str | None = None,
+        hosts: dict[str, str] | None = None,
+        access_token: str | None = None,
+        refresh_token: str | None = None,
+        on_token_refresh=None,
+    ) -> None:
+        self._config = {
+            'client_id': client_id or os.environ.get('MEDIAVIZ_CLIENT_ID'),
+            'client_secret': client_secret or os.environ.get('MEDIAVIZ_CLIENT_SECRET'),
+            'base_url': base_url or os.environ.get('MEDIAVIZ_BASE_URL') or 'https://api.mediaviz.ai',
+            'redirect_uri': redirect_uri or os.environ.get('MEDIAVIZ_REDIRECT_URI'),
+        }
+        _h = hosts or {}
+        self._hosts: dict[str, str | None] = {
+            'photoUpload': _h.get('photoUpload') or os.environ.get('MEDIAVIZ_PHOTO_UPLOAD_URL'),
+        }
+        self._hosts.update(_h)
+        self._access_token: str | None = access_token
+        self._refresh_token: str | None = refresh_token
+        self._on_token_refresh = on_token_refresh
+
+        _inner = OAuthClient(OAuthClientConfig(
+            base_url=self._config['base_url'],
+            client_id=self._config['client_id'] or '',
+            client_secret=self._config['client_secret'] or '',
+            redirect_uri=self._config['redirect_uri'] or '',
+        ))
+        self._tracking_client = _TokenTrackingClient(self, _inner)
+
+        _ctx = _Context(self)
+        self.admin = Admin(_ctx)
+        self.ai_model_credits = AiModelCredits(_ctx)
+        self.company = Company(_ctx)
+        self.curated_albums = CuratedAlbums(_ctx)
+        self.custom_albums = CustomAlbums(_ctx)
+        self.email_tokens = EmailTokens(_ctx)
+        self.health = Health(_ctx)
+        self.keywords = Keywords(_ctx)
+        self.o_auth_authorization = OAuthAuthorization(_ctx)
+        self.o_auth_token = OAuthToken(_ctx)
+        self.oauth_login = OauthLogin(_ctx)
+        self.person = Person(_ctx)
+        self.photo_upload = PhotoUpload(_ctx)
+        self.photos = Photos(_ctx)
+        self.projects = Projects(_ctx)
+        self.search = Search(_ctx)
+        self.users = Users(_ctx)
+
+    def authenticate(self) -> Any:
+        tokens = self._tracking_client._inner.get_client_credentials_token()
+        self._access_token = tokens.access_token
+        self._refresh_token = getattr(tokens, 'refresh_token', None)
+        return tokens
+
+    def get_authorization_url(self, state: str | None = None) -> Any:
+        return self._tracking_client._inner.generate_authorization_url(state)
+
+    def handle_callback(self, code: str, code_verifier: str) -> Any:
+        tokens = self._tracking_client._inner.exchange_code(code, code_verifier)
+        self._access_token = tokens.access_token
+        self._refresh_token = tokens.refresh_token
+        return tokens
+
+    def set_tokens(self, access_token: str, refresh_token: str) -> None:
+        self._access_token = access_token
+        self._refresh_token = refresh_token

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/company.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from typing import Any
+from urllib.parse import quote, urlencode
+import httpx
+
+from .errors import handle_response
+
+
+class Company:
+    def __init__(self, ctx) -> None:
+        self._ctx = ctx
+
+    def get_company_by_id(self, company_id: int) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/company/' + quote(str(company_id), safe='')
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def confirm_company_credit_balance(
+        self,
+        company_id: int,
+        photo_count: int | None = None,
+        models_list: Any | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/company/credit_balance/' + quote(str(company_id), safe='')
+        _q: dict[str, Any] = {}
+        if photo_count is not None:
+            _q['photo_count'] = photo_count
+        if models_list is not None:
+            _q['models_list'] = models_list if isinstance(models_list, (list, tuple)) else [models_list]
+        if _q:
+            path += '?' + urlencode(_q, doseq=True)
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/curated_albums.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+from typing import Any
+from urllib.parse import quote, urlencode
+import httpx
+
+from .errors import handle_response
+
+
+class CuratedAlbums:
+    def __init__(self, ctx) -> None:
+        self._ctx = ctx
+
+    def create_curated_album(
+        self,
+        project_table_name: str,
+        name: str,
+        description: str | None = None,
+        confidenceValue: float | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/project/' + quote(str(project_table_name), safe='')
+        body = {k: v for k, v in {
+            'name': name,
+            'description': description,
+            'confidence_value': confidenceValue,
+        }.items() if v is not None}
+        return self._ctx.client.request(path, 'POST', self._ctx.access_token, self._ctx.refresh_token, body).data
+
+    def get_all_project_curated_albums(self, project_table_name: str) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/project/' + quote(str(project_table_name), safe='')
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def get_curated_album_photos(
+        self,
+        album_id: int,
+        asc_or_desc: str | None = None,
+        last_id: Any | None = None,
+        limit: Any | None = None,
+        confidence_value: Any | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/photos/' + quote(str(album_id), safe='') + '/'
+        _q: dict[str, Any] = {}
+        if asc_or_desc is not None:
+            _q['asc_or_desc'] = asc_or_desc
+        if last_id is not None:
+            _q['last_id'] = last_id
+        if limit is not None:
+            _q['limit'] = limit
+        if confidence_value is not None:
+            _q['confidence_value'] = confidence_value
+        if _q:
+            path += '?' + urlencode(_q, doseq=True)
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def get_curated_album_photos_ranked(
+        self,
+        album_id: int,
+        asc_or_desc: str | None = None,
+        last_id: Any | None = None,
+        limit: Any | None = None,
+        confidence_value: Any | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/photos/ranked/' + quote(str(album_id), safe='') + '/'
+        _q: dict[str, Any] = {}
+        if asc_or_desc is not None:
+            _q['asc_or_desc'] = asc_or_desc
+        if last_id is not None:
+            _q['last_id'] = last_id
+        if limit is not None:
+            _q['limit'] = limit
+        if confidence_value is not None:
+            _q['confidence_value'] = confidence_value
+        if _q:
+            path += '?' + urlencode(_q, doseq=True)
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def get_curated_album_by_id(self, album_id: int) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/' + quote(str(album_id), safe='')
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def update_curated_album(
+        self,
+        album_id: int,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        confidenceValue: float | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/' + quote(str(album_id), safe='')
+        body = {k: v for k, v in {
+            'name': name,
+            'description': description,
+            'confidence_value': confidenceValue,
+        }.items() if v is not None}
+        return self._ctx.client.request(path, 'PUT', self._ctx.access_token, self._ctx.refresh_token, body).data
+
+    def delete_curated_album(self, album_id: int) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/' + quote(str(album_id), safe='')
+        return self._ctx.client.request(path, 'DELETE', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def convert_curated_album_to_custom(self, album_id: int) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/curated_album/' + quote(str(album_id), safe='') + '/convert'
+        return self._ctx.client.request(path, 'POST', self._ctx.access_token, self._ctx.refresh_token).data

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/custom_albums.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+from typing import Any
+from urllib.parse import quote, urlencode
+import httpx
+
+from .errors import handle_response
+
+
+class CustomAlbums:
+    def __init__(self, ctx) -> None:
+        self._ctx = ctx
+
+    def get_custom_album_detail_by_id(self, custom_album_id: int) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/custom_album/' + quote(str(custom_album_id), safe='')
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def get_all_project_custom_albums(self, project_table_name: str) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/custom_album/project/' + quote(str(project_table_name), safe='')
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def get_custom_album_photos_by_id(
+        self,
+        custom_album_id: int,
+        asc_or_desc: str | None = None,
+        last_id: Any | None = None,
+        limit: Any | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/custom_album/photos/' + quote(str(custom_album_id), safe='') + '/'
+        _q: dict[str, Any] = {}
+        if asc_or_desc is not None:
+            _q['asc_or_desc'] = asc_or_desc
+        if last_id is not None:
+            _q['last_id'] = last_id
+        if limit is not None:
+            _q['limit'] = limit
+        if _q:
+            path += '?' + urlencode(_q, doseq=True)
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def get_ranked_custom_album_by_id(
+        self,
+        custom_album_id: int,
+        asc_or_desc: str | None = None,
+        last_id: Any | None = None,
+        limit: Any | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/custom_album/photos/ranked/' + quote(str(custom_album_id), safe='') + '/'
+        _q: dict[str, Any] = {}
+        if asc_or_desc is not None:
+            _q['asc_or_desc'] = asc_or_desc
+        if last_id is not None:
+            _q['last_id'] = last_id
+        if limit is not None:
+            _q['limit'] = limit
+        if _q:
+            path += '?' + urlencode(_q, doseq=True)
+        return self._ctx.client.request(path, 'GET', self._ctx.access_token, self._ctx.refresh_token).data
+
+    def create_project_custom_album(
+        self,
+        project_table_name: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        photoIdInclusionList: list | None = None,
+        photoIdRemovalList: list | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/custom_album/project/' + quote(str(project_table_name), safe='')
+        body = {k: v for k, v in {
+            'name': name,
+            'description': description,
+            'photo_id_inclusion_list': photoIdInclusionList,
+            'photo_id_removal_list': photoIdRemovalList,
+        }.items() if v is not None}
+        return self._ctx.client.request(path, 'POST', self._ctx.access_token, self._ctx.refresh_token, body).data
+
+    def update_custom_album(
+        self,
+        album_id: int,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        photoIdInclusionList: list | None = None,
+        photoIdRemovalList: list | None = None,
+    ) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/custom_album/' + quote(str(album_id), safe='')
+        body = {k: v for k, v in {
+            'name': name,
+            'description': description,
+            'photo_id_inclusion_list': photoIdInclusionList,
+            'photo_id_removal_list': photoIdRemovalList,
+        }.items() if v is not None}
+        return self._ctx.client.request(path, 'PUT', self._ctx.access_token, self._ctx.refresh_token, body).data
+
+    def delete_custom_album(self, album_id: int) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/custom_album/' + quote(str(album_id), safe='')
+        return self._ctx.client.request(path, 'DELETE', self._ctx.access_token, self._ctx.refresh_token).data

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/email_tokens.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+from typing import Any
+from urllib.parse import quote, urlencode
+import httpx
+
+from .errors import handle_response
+
+
+class EmailTokens:
+    def __init__(self, ctx) -> None:
+        self._ctx = ctx
+
+    def request_email_verification(self, email: str | None = None) -> dict[str, Any]:
+        path = '/api/v1/request-email-verification'
+        _q: dict[str, Any] = {}
+        if email is not None:
+            _q['email'] = email
+        if _q:
+            path += '?' + urlencode(_q, doseq=True)
+        with httpx.Client() as _client:
+            _resp = _client.request('POST', self._ctx.base_url + path)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))
+
+    def verify_email(self, token: str) -> dict[str, Any]:
+        path = '/api/v1/verify-email/' + quote(str(token), safe='')
+        with httpx.Client() as _client:
+            _resp = _client.request('POST', self._ctx.base_url + path)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))
+
+    def request_password_reset(self, email: str | None = None) -> dict[str, Any]:
+        path = '/api/v1/request-password-reset'
+        _q: dict[str, Any] = {}
+        if email is not None:
+            _q['email'] = email
+        if _q:
+            path += '?' + urlencode(_q, doseq=True)
+        with httpx.Client() as _client:
+            _resp = _client.request('POST', self._ctx.base_url + path)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))
+
+    def validate_token(self, token: str) -> dict[str, Any]:
+        path = '/api/v1/validate-token'
+        body = {k: v for k, v in {
+            'token': token,
+        }.items() if v is not None}
+        with httpx.Client() as _client:
+            _resp = _client.request('POST', self._ctx.base_url + path, json=body)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))
+
+    def reset_password(self, token: str, newPassword: str) -> dict[str, Any]:
+        path = '/api/v1/reset-password'
+        body = {k: v for k, v in {
+            'token': token,
+            'new_password': newPassword,
+        }.items() if v is not None}
+        with httpx.Client() as _client:
+            _resp = _client.request('POST', self._ctx.base_url + path, json=body)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))
+
+    def delete_user_email_tokens(self, user_id: int) -> dict[str, Any]:
+        self._ctx.require_tokens()
+        path = '/api/v1/admin/email_tokens/by_user/' + quote(str(user_id), safe='')
+        return self._ctx.client.request(path, 'DELETE', self._ctx.access_token, self._ctx.refresh_token).data

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/errors.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+import json
+from typing import Any
+
+
+class ApiError(Exception):
+    def __init__(self, message: str, status: int, request_id: str | None, body: Any) -> None:
+        super().__init__(message)
+        self.status = status
+        self.request_id = request_id
+        self.body = body
+
+
+class ValidationError(ApiError):
+    field_errors: list[dict]
+
+    def __init__(self, body: Any, status: int, request_id: str | None) -> None:
+        detail = body.get("detail", []) if isinstance(body, dict) else []
+        if isinstance(detail, list) and detail:
+            message = "; ".join(
+                ".".join(str(loc) for loc in d.get("loc", [])) + ": " + d.get("msg", "")
+                for d in detail
+            )
+            self.field_errors = [
+                {"loc": d.get("loc", []), "msg": d.get("msg", ""), "type": d.get("type", "")}
+                for d in detail
+            ]
+        else:
+            message = detail if isinstance(detail, str) else "Validation failed"
+            self.field_errors = []
+        super().__init__(message, status, request_id, body)
+
+
+class NotFoundError(ApiError):
+    def __init__(self, body: Any, status: int, request_id: str | None) -> None:
+        detail = body.get("detail", "Resource not found") if isinstance(body, dict) else "Resource not found"
+        super().__init__(detail, status, request_id, body)
+
+
+class RateLimitError(ApiError):
+    retry_after: int | None
+
+    def __init__(self, body: Any, status: int, request_id: str | None, retry_after: int | None) -> None:
+        detail = body.get("detail", "Rate limited") if isinstance(body, dict) else "Rate limited"
+        self.retry_after = retry_after
+        super().__init__(detail, status, request_id, body)
+
+
+class ServerError(ApiError):
+    def __init__(self, body: Any, status: int, request_id: str | None) -> None:
+        detail = body.get("detail", "Internal server error") if isinstance(body, dict) else "Internal server error"
+        super().__init__(detail, status, request_id, body)
+
+
+def handle_response(raw: str, status: int, headers: dict[str, str]) -> Any:
+    request_id = headers.get("x-request-id")
+    body: Any = json.loads(raw) if raw else {}
+    if 200 <= status < 300:
+        return body
+    if status == 422:
+        raise ValidationError(body, status, request_id)
+    if status == 404:
+        raise NotFoundError(body, status, request_id)
+    if status == 429:
+        retry_after = int(headers["retry-after"]) if "retry-after" in headers else None
+        raise RateLimitError(body, status, request_id, retry_after)
+    if status >= 500:
+        raise ServerError(body, status, request_id)
+    detail = body.get("detail", "Unknown error") if isinstance(body, dict) else "Unknown error"
+    raise ApiError(detail, status, request_id, body)

mediaviz_sdk-1.0.5.81.dev0/mediaviz_sdk/health.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+from typing import Any
+from urllib.parse import quote, urlencode
+import httpx
+
+from .errors import handle_response
+
+
+class Health:
+    def __init__(self, ctx) -> None:
+        self._ctx = ctx
+
+    def health_check(self) -> dict[str, Any]:
+        path = '/api/v1/health/'
+        with httpx.Client() as _client:
+            _resp = _client.request('GET', self._ctx.base_url + path)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))
+
+    def liveness_check(self) -> dict[str, Any]:
+        path = '/api/v1/health/live/'
+        with httpx.Client() as _client:
+            _resp = _client.request('GET', self._ctx.base_url + path)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))
+
+    def readiness_check(self) -> dict[str, Any]:
+        path = '/api/v1/health/ready'
+        with httpx.Client() as _client:
+            _resp = _client.request('GET', self._ctx.base_url + path)
+        return handle_response(_resp.text, _resp.status_code, dict(_resp.headers))