nadeshiko-sdk 0.1.0__py3-none-any.whl

nadeshiko/models/media_info_path.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MediaInfoPath")
+
+
+@_attrs_define
+class MediaInfoPath:
+    """URLs to media resources for a segment
+
+    Attributes:
+        path_image (str | Unset): URL to the subtitle image snapshot Example: https://example.com/media/anime/steins-
+            gate/segments/1133.jpg.
+        path_audio (str | Unset): URL to the audio clip for this segment Example:
+            https://example.com/media/anime/steins-gate/audio/1133.mp3.
+        path_video (str | Unset): URL to the video clip for this segment Example:
+            https://example.com/media/anime/steins-gate/video/1133.mp4.
+    """
+
+    path_image: str | Unset = UNSET
+    path_audio: str | Unset = UNSET
+    path_video: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        path_image = self.path_image
+
+        path_audio = self.path_audio
+
+        path_video = self.path_video
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if path_image is not UNSET:
+            field_dict["path_image"] = path_image
+        if path_audio is not UNSET:
+            field_dict["path_audio"] = path_audio
+        if path_video is not UNSET:
+            field_dict["path_video"] = path_video
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        path_image = d.pop("path_image", UNSET)
+
+        path_audio = d.pop("path_audio", UNSET)
+
+        path_video = d.pop("path_video", UNSET)
+
+        media_info_path = cls(
+            path_image=path_image,
+            path_audio=path_audio,
+            path_video=path_video,
+        )
+
+        media_info_path.additional_properties = d
+        return media_info_path
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

nadeshiko/models/media_info_stats.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MediaInfoStats")
+
+
+@_attrs_define
+class MediaInfoStats:
+    """Statistics about media and segments in the database
+
+    Attributes:
+        total_animes (int | Unset): Number of anime/media entries in the current result set Example: 15.
+        total_segments (int | Unset): Number of subtitle segments in the current result set Example: 150.
+        full_total_animes (int | Unset): Total number of anime/media entries in the entire database Example: 5234.
+        full_total_segments (int | Unset): Total number of subtitle segments in the entire database Example: 1523847.
+    """
+
+    total_animes: int | Unset = UNSET
+    total_segments: int | Unset = UNSET
+    full_total_animes: int | Unset = UNSET
+    full_total_segments: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        total_animes = self.total_animes
+
+        total_segments = self.total_segments
+
+        full_total_animes = self.full_total_animes
+
+        full_total_segments = self.full_total_segments
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if total_animes is not UNSET:
+            field_dict["total_animes"] = total_animes
+        if total_segments is not UNSET:
+            field_dict["total_segments"] = total_segments
+        if full_total_animes is not UNSET:
+            field_dict["full_total_animes"] = full_total_animes
+        if full_total_segments is not UNSET:
+            field_dict["full_total_segments"] = full_total_segments
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        total_animes = d.pop("total_animes", UNSET)
+
+        total_segments = d.pop("total_segments", UNSET)
+
+        full_total_animes = d.pop("full_total_animes", UNSET)
+
+        full_total_segments = d.pop("full_total_segments", UNSET)
+
+        media_info_stats = cls(
+            total_animes=total_animes,
+            total_segments=total_segments,
+            full_total_animes=full_total_animes,
+            full_total_segments=full_total_segments,
+        )
+
+        media_info_stats.additional_properties = d
+        return media_info_stats
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

nadeshiko/models/media_list_response.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.media import Media
+
+
+T = TypeVar("T", bound="MediaListResponse")
+
+
+@_attrs_define
+class MediaListResponse:
+    """
+    Attributes:
+        data (list[Media]):
+        has_more_results (bool): Whether more results are available
+        cursor (int | Unset): Next cursor for pagination (undefined if no more results)
+    """
+
+    data: list[Media]
+    has_more_results: bool
+    cursor: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        has_more_results = self.has_more_results
+
+        cursor = self.cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+                "hasMoreResults": has_more_results,
+            }
+        )
+        if cursor is not UNSET:
+            field_dict["cursor"] = cursor
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.media import Media
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = Media.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        has_more_results = d.pop("hasMoreResults")
+
+        cursor = d.pop("cursor", UNSET)
+
+        media_list_response = cls(
+            data=data,
+            has_more_results=has_more_results,
+            cursor=cursor,
+        )
+
+        media_list_response.additional_properties = d
+        return media_list_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

nadeshiko/models/media_update_request.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.media_update_request_category import MediaUpdateRequestCategory
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.character_input import CharacterInput
+    from ..models.list_input import ListInput
+
+
+T = TypeVar("T", bound="MediaUpdateRequest")
+
+
+@_attrs_define
+class MediaUpdateRequest:
+    """Request body for updating an existing media entry (all fields optional)
+
+    Attributes:
+        anilist_id (int | Unset): AniList database ID for the media Example: 7674.
+        japanese_name (str | Unset): Original Japanese name of the media Example: バクマン。.
+        romaji_name (str | Unset): Romaji transliteration of the media name Example: Bakuman..
+        english_name (str | Unset): English translation of the media name Example: Bakuman..
+        airing_format (str | Unset): Format of the media release (e.g., TV, OVA, Movie) Example: TV.
+        airing_status (str | Unset): Current airing status (FINISHED, RELEASING, NOT_YET_RELEASED, CANCELLED) Example:
+            FINISHED.
+        genres (list[str] | Unset): List of genres associated with the media Example: ['Comedy', 'Drama', 'Romance',
+            'Slice of Life'].
+        cover_url (str | Unset): Full URL to the cover image Example:
+            https://cdn.example.com/media/anime/bakuman/cover.webp.
+        banner_url (str | Unset): Full URL to the banner image Example:
+            https://cdn.example.com/media/anime/bakuman/banner.webp.
+        start_date (datetime.datetime | Unset): Start date of the media (first airing/release) Example: 2010-10-02
+            00:00:00+00:00.
+        end_date (datetime.datetime | Unset): End date of the media (last airing/release) Example: 2011-04-02
+            00:00:00+00:00.
+        category (MediaUpdateRequestCategory | Unset): Media category Example: ANIME.
+        num_segments (int | Unset): Total number of subtitle segments available Example: 1234.
+        version (str | Unset): Version identifier for the media entry Example: 6.
+        hash_salt (str | Unset): Hash salt for data integrity verification Example: ba0cbe173ed310528f16130273662a60.
+        studio (str | Unset): Animation studio that produced the media Example: J.C.STAFF.
+        season_name (str | Unset): Season when the media aired (WINTER, SPRING, SUMMER, FALL) Example: FALL.
+        season_year (int | Unset): Year when the media aired Example: 2010.
+        characters (list[CharacterInput] | Unset): List of characters appearing in the media with their voice actors
+        lists (list[ListInput] | Unset): Lists to add this media to (e.g., series, franchise)
+    """
+
+    anilist_id: int | Unset = UNSET
+    japanese_name: str | Unset = UNSET
+    romaji_name: str | Unset = UNSET
+    english_name: str | Unset = UNSET
+    airing_format: str | Unset = UNSET
+    airing_status: str | Unset = UNSET
+    genres: list[str] | Unset = UNSET
+    cover_url: str | Unset = UNSET
+    banner_url: str | Unset = UNSET
+    start_date: datetime.datetime | Unset = UNSET
+    end_date: datetime.datetime | Unset = UNSET
+    category: MediaUpdateRequestCategory | Unset = UNSET
+    num_segments: int | Unset = UNSET
+    version: str | Unset = UNSET
+    hash_salt: str | Unset = UNSET
+    studio: str | Unset = UNSET
+    season_name: str | Unset = UNSET
+    season_year: int | Unset = UNSET
+    characters: list[CharacterInput] | Unset = UNSET
+    lists: list[ListInput] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        anilist_id = self.anilist_id
+
+        japanese_name = self.japanese_name
+
+        romaji_name = self.romaji_name
+
+        english_name = self.english_name
+
+        airing_format = self.airing_format
+
+        airing_status = self.airing_status
+
+        genres: list[str] | Unset = UNSET
+        if not isinstance(self.genres, Unset):
+            genres = self.genres
+
+        cover_url = self.cover_url
+
+        banner_url = self.banner_url
+
+        start_date: str | Unset = UNSET
+        if not isinstance(self.start_date, Unset):
+            start_date = self.start_date.isoformat()
+
+        end_date: str | Unset = UNSET
+        if not isinstance(self.end_date, Unset):
+            end_date = self.end_date.isoformat()
+
+        category: str | Unset = UNSET
+        if not isinstance(self.category, Unset):
+            category = self.category.value
+
+        num_segments = self.num_segments
+
+        version = self.version
+
+        hash_salt = self.hash_salt
+
+        studio = self.studio
+
+        season_name = self.season_name
+
+        season_year = self.season_year
+
+        characters: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.characters, Unset):
+            characters = []
+            for characters_item_data in self.characters:
+                characters_item = characters_item_data.to_dict()
+                characters.append(characters_item)
+
+        lists: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.lists, Unset):
+            lists = []
+            for lists_item_data in self.lists:
+                lists_item = lists_item_data.to_dict()
+                lists.append(lists_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if anilist_id is not UNSET:
+            field_dict["anilistId"] = anilist_id
+        if japanese_name is not UNSET:
+            field_dict["japaneseName"] = japanese_name
+        if romaji_name is not UNSET:
+            field_dict["romajiName"] = romaji_name
+        if english_name is not UNSET:
+            field_dict["englishName"] = english_name
+        if airing_format is not UNSET:
+            field_dict["airingFormat"] = airing_format
+        if airing_status is not UNSET:
+            field_dict["airingStatus"] = airing_status
+        if genres is not UNSET:
+            field_dict["genres"] = genres
+        if cover_url is not UNSET:
+            field_dict["coverUrl"] = cover_url
+        if banner_url is not UNSET:
+            field_dict["bannerUrl"] = banner_url
+        if start_date is not UNSET:
+            field_dict["startDate"] = start_date
+        if end_date is not UNSET:
+            field_dict["endDate"] = end_date
+        if category is not UNSET:
+            field_dict["category"] = category
+        if num_segments is not UNSET:
+            field_dict["numSegments"] = num_segments
+        if version is not UNSET:
+            field_dict["version"] = version
+        if hash_salt is not UNSET:
+            field_dict["hashSalt"] = hash_salt
+        if studio is not UNSET:
+            field_dict["studio"] = studio
+        if season_name is not UNSET:
+            field_dict["seasonName"] = season_name
+        if season_year is not UNSET:
+            field_dict["seasonYear"] = season_year
+        if characters is not UNSET:
+            field_dict["characters"] = characters
+        if lists is not UNSET:
+            field_dict["lists"] = lists
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.character_input import CharacterInput
+        from ..models.list_input import ListInput
+
+        d = dict(src_dict)
+        anilist_id = d.pop("anilistId", UNSET)
+
+        japanese_name = d.pop("japaneseName", UNSET)
+
+        romaji_name = d.pop("romajiName", UNSET)
+
+        english_name = d.pop("englishName", UNSET)
+
+        airing_format = d.pop("airingFormat", UNSET)
+
+        airing_status = d.pop("airingStatus", UNSET)
+
+        genres = cast(list[str], d.pop("genres", UNSET))
+
+        cover_url = d.pop("coverUrl", UNSET)
+
+        banner_url = d.pop("bannerUrl", UNSET)
+
+        _start_date = d.pop("startDate", UNSET)
+        start_date: datetime.datetime | Unset
+        if isinstance(_start_date, Unset):
+            start_date = UNSET
+        else:
+            start_date = isoparse(_start_date)
+
+        _end_date = d.pop("endDate", UNSET)
+        end_date: datetime.datetime | Unset
+        if isinstance(_end_date, Unset):
+            end_date = UNSET
+        else:
+            end_date = isoparse(_end_date)
+
+        _category = d.pop("category", UNSET)
+        category: MediaUpdateRequestCategory | Unset
+        if isinstance(_category, Unset):
+            category = UNSET
+        else:
+            category = MediaUpdateRequestCategory(_category)
+
+        num_segments = d.pop("numSegments", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        hash_salt = d.pop("hashSalt", UNSET)
+
+        studio = d.pop("studio", UNSET)
+
+        season_name = d.pop("seasonName", UNSET)
+
+        season_year = d.pop("seasonYear", UNSET)
+
+        _characters = d.pop("characters", UNSET)
+        characters: list[CharacterInput] | Unset = UNSET
+        if _characters is not UNSET:
+            characters = []
+            for characters_item_data in _characters:
+                characters_item = CharacterInput.from_dict(characters_item_data)
+
+                characters.append(characters_item)
+
+        _lists = d.pop("lists", UNSET)
+        lists: list[ListInput] | Unset = UNSET
+        if _lists is not UNSET:
+            lists = []
+            for lists_item_data in _lists:
+                lists_item = ListInput.from_dict(lists_item_data)
+
+                lists.append(lists_item)
+
+        media_update_request = cls(
+            anilist_id=anilist_id,
+            japanese_name=japanese_name,
+            romaji_name=romaji_name,
+            english_name=english_name,
+            airing_format=airing_format,
+            airing_status=airing_status,
+            genres=genres,
+            cover_url=cover_url,
+            banner_url=banner_url,
+            start_date=start_date,
+            end_date=end_date,
+            category=category,
+            num_segments=num_segments,
+            version=version,
+            hash_salt=hash_salt,
+            studio=studio,
+            season_name=season_name,
+            season_year=season_year,
+            characters=characters,
+            lists=lists,
+        )
+
+        media_update_request.additional_properties = d
+        return media_update_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

nadeshiko/models/media_update_request_category.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class MediaUpdateRequestCategory(str, Enum):
+    ANIME = "ANIME"
+    AUDIOBOOK = "AUDIOBOOK"
+
+    def __str__(self) -> str:
+        return str(self.value)

nadeshiko/models/quota_info.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.quota_info_quota_limit_type_1 import QuotaInfoQuotaLimitType1
+
+T = TypeVar("T", bound="QuotaInfo")
+
+
+@_attrs_define
+class QuotaInfo:
+    """User quota information
+
+    Attributes:
+        quota_used (int): Number of API requests used this month
+        quota_limit (int | QuotaInfoQuotaLimitType1):
+    """
+
+    quota_used: int
+    quota_limit: int | QuotaInfoQuotaLimitType1
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        quota_used = self.quota_used
+
+        quota_limit: int | str
+        if isinstance(self.quota_limit, QuotaInfoQuotaLimitType1):
+            quota_limit = self.quota_limit.value
+        else:
+            quota_limit = self.quota_limit
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "quotaUsed": quota_used,
+                "quotaLimit": quota_limit,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        quota_used = d.pop("quotaUsed")
+
+        def _parse_quota_limit(data: object) -> int | QuotaInfoQuotaLimitType1:
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                quota_limit_type_1 = QuotaInfoQuotaLimitType1(data)
+
+                return quota_limit_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(int | QuotaInfoQuotaLimitType1, data)
+
+        quota_limit = _parse_quota_limit(d.pop("quotaLimit"))
+
+        quota_info = cls(
+            quota_used=quota_used,
+            quota_limit=quota_limit,
+        )
+
+        quota_info.additional_properties = d
+        return quota_info
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

nadeshiko/models/quota_info_quota_limit_type_1.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class QuotaInfoQuotaLimitType1(str, Enum):
+    NO_LIMIT = "NO_LIMIT"
+
+    def __str__(self) -> str:
+        return str(self.value)