nadeshiko-sdk 0.1.0__py3-none-any.whl

nadeshiko/models/seiyuu_with_roles.py

@@ -0,0 +1,108 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.seiyuu_with_roles_roles_item import SeiyuuWithRolesRolesItem
+
+
+T = TypeVar("T", bound="SeiyuuWithRoles")
+
+
+@_attrs_define
+class SeiyuuWithRoles:
+    """Seiyuu with all voice acting roles
+
+    Attributes:
+        id (int): AniList staff ID Example: 95991.
+        name_japanese (str): Japanese name of the voice actor Example: 阿部敦.
+        name_english (str): English name of the voice actor Example: Atsushi Abe.
+        image_url (str): Profile image URL Example: https://s4.anilist.co/file/anilistcdn/staff/large/n95991.jpg.
+        roles (list[SeiyuuWithRolesRolesItem]): All characters voiced by this seiyuu with their media appearances
+    """
+
+    id: int
+    name_japanese: str
+    name_english: str
+    image_url: str
+    roles: list[SeiyuuWithRolesRolesItem]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name_japanese = self.name_japanese
+
+        name_english = self.name_english
+
+        image_url = self.image_url
+
+        roles = []
+        for roles_item_data in self.roles:
+            roles_item = roles_item_data.to_dict()
+            roles.append(roles_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "nameJapanese": name_japanese,
+                "nameEnglish": name_english,
+                "imageUrl": image_url,
+                "roles": roles,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.seiyuu_with_roles_roles_item import SeiyuuWithRolesRolesItem
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name_japanese = d.pop("nameJapanese")
+
+        name_english = d.pop("nameEnglish")
+
+        image_url = d.pop("imageUrl")
+
+        roles = []
+        _roles = d.pop("roles")
+        for roles_item_data in _roles:
+            roles_item = SeiyuuWithRolesRolesItem.from_dict(roles_item_data)
+
+            roles.append(roles_item)
+
+        seiyuu_with_roles = cls(
+            id=id,
+            name_japanese=name_japanese,
+            name_english=name_english,
+            image_url=image_url,
+            roles=roles,
+        )
+
+        seiyuu_with_roles.additional_properties = d
+        return seiyuu_with_roles
+
+    @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/seiyuu_with_roles_roles_item.py

@@ -0,0 +1,109 @@
+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 ..models.seiyuu_with_roles_roles_item_role import SeiyuuWithRolesRolesItemRole
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.character import Character
+    from ..models.media import Media
+
+
+T = TypeVar("T", bound="SeiyuuWithRolesRolesItem")
+
+
+@_attrs_define
+class SeiyuuWithRolesRolesItem:
+    """
+    Attributes:
+        character (Character | Unset): Anime character
+        media (Media | Unset): Media entry with full metadata
+        role (SeiyuuWithRolesRolesItemRole | Unset): Character role in this media Example: MAIN.
+    """
+
+    character: Character | Unset = UNSET
+    media: Media | Unset = UNSET
+    role: SeiyuuWithRolesRolesItemRole | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        character: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.character, Unset):
+            character = self.character.to_dict()
+
+        media: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.media, Unset):
+            media = self.media.to_dict()
+
+        role: str | Unset = UNSET
+        if not isinstance(self.role, Unset):
+            role = self.role.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if character is not UNSET:
+            field_dict["character"] = character
+        if media is not UNSET:
+            field_dict["media"] = media
+        if role is not UNSET:
+            field_dict["role"] = role
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.character import Character
+        from ..models.media import Media
+
+        d = dict(src_dict)
+        _character = d.pop("character", UNSET)
+        character: Character | Unset
+        if isinstance(_character, Unset):
+            character = UNSET
+        else:
+            character = Character.from_dict(_character)
+
+        _media = d.pop("media", UNSET)
+        media: Media | Unset
+        if isinstance(_media, Unset):
+            media = UNSET
+        else:
+            media = Media.from_dict(_media)
+
+        _role = d.pop("role", UNSET)
+        role: SeiyuuWithRolesRolesItemRole | Unset
+        if isinstance(_role, Unset):
+            role = UNSET
+        else:
+            role = SeiyuuWithRolesRolesItemRole(_role)
+
+        seiyuu_with_roles_roles_item = cls(
+            character=character,
+            media=media,
+            role=role,
+        )
+
+        seiyuu_with_roles_roles_item.additional_properties = d
+        return seiyuu_with_roles_roles_item
+
+    @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/seiyuu_with_roles_roles_item_role.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SeiyuuWithRolesRolesItemRole(str, Enum):
+    BACKGROUND = "BACKGROUND"
+    MAIN = "MAIN"
+    SUPPORTING = "SUPPORTING"
+
+    def __str__(self) -> str:
+        return str(self.value)

nadeshiko/models/sentence.py

@@ -0,0 +1,88 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.basic_info import BasicInfo
+    from ..models.media_info_path import MediaInfoPath
+    from ..models.segment_info import SegmentInfo
+
+
+T = TypeVar("T", bound="Sentence")
+
+
+@_attrs_define
+class Sentence:
+    """A complete sentence result combining basic info, segment details, and media paths
+
+    Attributes:
+        basic_info (BasicInfo): Basic anime/media information included in search results
+        segment_info (SegmentInfo): Detailed information about a subtitle segment
+        media_info (MediaInfoPath): URLs to media resources for a segment
+    """
+
+    basic_info: BasicInfo
+    segment_info: SegmentInfo
+    media_info: MediaInfoPath
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        basic_info = self.basic_info.to_dict()
+
+        segment_info = self.segment_info.to_dict()
+
+        media_info = self.media_info.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "basic_info": basic_info,
+                "segment_info": segment_info,
+                "media_info": media_info,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.basic_info import BasicInfo
+        from ..models.media_info_path import MediaInfoPath
+        from ..models.segment_info import SegmentInfo
+
+        d = dict(src_dict)
+        basic_info = BasicInfo.from_dict(d.pop("basic_info"))
+
+        segment_info = SegmentInfo.from_dict(d.pop("segment_info"))
+
+        media_info = MediaInfoPath.from_dict(d.pop("media_info"))
+
+        sentence = cls(
+            basic_info=basic_info,
+            segment_info=segment_info,
+            media_info=media_info,
+        )
+
+        sentence.additional_properties = d
+        return sentence
+
+    @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/statistic.py

@@ -0,0 +1,132 @@
+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.statistic_season_with_episode_hits import StatisticSeasonWithEpisodeHits
+
+
+T = TypeVar("T", bound="Statistic")
+
+
+@_attrs_define
+class Statistic:
+    """Search result statistics grouped by anime/media
+
+    Attributes:
+        anime_id (int | Unset): Unique identifier for the anime/media Example: 110316.
+        category (int | Unset): Media category (1=Anime, 2=Unknown, 3=J-Drama, 4=Audiobook) Example: 1.
+        name_anime_romaji (str | Unset): Romaji transliteration of the anime name Example: Steins;Gate.
+        name_anime_en (str | Unset): English translation of the anime name Example: Steins;Gate.
+        name_anime_jp (str | Unset): Original Japanese name of the anime Example: シュタインズ・ゲート.
+        amount_sentences_found (int | Unset): Total number of sentences found for this anime Example: 42.
+        season_with_episode_hits (StatisticSeasonWithEpisodeHits | Unset): Nested object mapping seasons to episodes
+            with hit counts Example: {'1': {'1': 5, '2': 8, '3': 3}}.
+    """
+
+    anime_id: int | Unset = UNSET
+    category: int | Unset = UNSET
+    name_anime_romaji: str | Unset = UNSET
+    name_anime_en: str | Unset = UNSET
+    name_anime_jp: str | Unset = UNSET
+    amount_sentences_found: int | Unset = UNSET
+    season_with_episode_hits: StatisticSeasonWithEpisodeHits | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        anime_id = self.anime_id
+
+        category = self.category
+
+        name_anime_romaji = self.name_anime_romaji
+
+        name_anime_en = self.name_anime_en
+
+        name_anime_jp = self.name_anime_jp
+
+        amount_sentences_found = self.amount_sentences_found
+
+        season_with_episode_hits: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.season_with_episode_hits, Unset):
+            season_with_episode_hits = self.season_with_episode_hits.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if anime_id is not UNSET:
+            field_dict["anime_id"] = anime_id
+        if category is not UNSET:
+            field_dict["category"] = category
+        if name_anime_romaji is not UNSET:
+            field_dict["name_anime_romaji"] = name_anime_romaji
+        if name_anime_en is not UNSET:
+            field_dict["name_anime_en"] = name_anime_en
+        if name_anime_jp is not UNSET:
+            field_dict["name_anime_jp"] = name_anime_jp
+        if amount_sentences_found is not UNSET:
+            field_dict["amount_sentences_found"] = amount_sentences_found
+        if season_with_episode_hits is not UNSET:
+            field_dict["season_with_episode_hits"] = season_with_episode_hits
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.statistic_season_with_episode_hits import StatisticSeasonWithEpisodeHits
+
+        d = dict(src_dict)
+        anime_id = d.pop("anime_id", UNSET)
+
+        category = d.pop("category", UNSET)
+
+        name_anime_romaji = d.pop("name_anime_romaji", UNSET)
+
+        name_anime_en = d.pop("name_anime_en", UNSET)
+
+        name_anime_jp = d.pop("name_anime_jp", UNSET)
+
+        amount_sentences_found = d.pop("amount_sentences_found", UNSET)
+
+        _season_with_episode_hits = d.pop("season_with_episode_hits", UNSET)
+        season_with_episode_hits: StatisticSeasonWithEpisodeHits | Unset
+        if isinstance(_season_with_episode_hits, Unset):
+            season_with_episode_hits = UNSET
+        else:
+            season_with_episode_hits = StatisticSeasonWithEpisodeHits.from_dict(
+                _season_with_episode_hits
+            )
+
+        statistic = cls(
+            anime_id=anime_id,
+            category=category,
+            name_anime_romaji=name_anime_romaji,
+            name_anime_en=name_anime_en,
+            name_anime_jp=name_anime_jp,
+            amount_sentences_found=amount_sentences_found,
+            season_with_episode_hits=season_with_episode_hits,
+        )
+
+        statistic.additional_properties = d
+        return statistic
+
+    @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/statistic_season_with_episode_hits.py

@@ -0,0 +1,74 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.statistic_season_with_episode_hits_additional_property import (
+        StatisticSeasonWithEpisodeHitsAdditionalProperty,
+    )
+
+
+T = TypeVar("T", bound="StatisticSeasonWithEpisodeHits")
+
+
+@_attrs_define
+class StatisticSeasonWithEpisodeHits:
+    """Nested object mapping seasons to episodes with hit counts
+
+    Example:
+        {'1': {'1': 5, '2': 8, '3': 3}}
+
+    """
+
+    additional_properties: dict[str, StatisticSeasonWithEpisodeHitsAdditionalProperty] = (
+        _attrs_field(init=False, factory=dict)
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.statistic_season_with_episode_hits_additional_property import (
+            StatisticSeasonWithEpisodeHitsAdditionalProperty,
+        )
+
+        d = dict(src_dict)
+        statistic_season_with_episode_hits = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = StatisticSeasonWithEpisodeHitsAdditionalProperty.from_dict(
+                prop_dict
+            )
+
+            additional_properties[prop_name] = additional_property
+
+        statistic_season_with_episode_hits.additional_properties = additional_properties
+        return statistic_season_with_episode_hits
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> StatisticSeasonWithEpisodeHitsAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(
+        self, key: str, value: StatisticSeasonWithEpisodeHitsAdditionalProperty
+    ) -> 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/statistic_season_with_episode_hits_additional_property.py

@@ -0,0 +1,46 @@
+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
+
+T = TypeVar("T", bound="StatisticSeasonWithEpisodeHitsAdditionalProperty")
+
+
+@_attrs_define
+class StatisticSeasonWithEpisodeHitsAdditionalProperty:
+    """ """
+
+    additional_properties: dict[str, int] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        statistic_season_with_episode_hits_additional_property = cls()
+
+        statistic_season_with_episode_hits_additional_property.additional_properties = d
+        return statistic_season_with_episode_hits_additional_property
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> int:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: int) -> 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/user_info_response.py

@@ -0,0 +1,79 @@
+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.user_info_response_user import UserInfoResponseUser
+
+
+T = TypeVar("T", bound="UserInfoResponse")
+
+
+@_attrs_define
+class UserInfoResponse:
+    """User info response
+
+    Attributes:
+        user (UserInfoResponseUser):
+        status (int | Unset): HTTP status code
+    """
+
+    user: UserInfoResponseUser
+    status: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        user = self.user.to_dict()
+
+        status = self.status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "user": user,
+            }
+        )
+        if status is not UNSET:
+            field_dict["status"] = status
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.user_info_response_user import UserInfoResponseUser
+
+        d = dict(src_dict)
+        user = UserInfoResponseUser.from_dict(d.pop("user"))
+
+        status = d.pop("status", UNSET)
+
+        user_info_response = cls(
+            user=user,
+            status=status,
+        )
+
+        user_info_response.additional_properties = d
+        return user_info_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