nadeshiko-sdk 0.1.0__py3-none-any.whl

nadeshiko/models/category_statistic.py

@@ -0,0 +1,71 @@
+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="CategoryStatistic")
+
+
+@_attrs_define
+class CategoryStatistic:
+    """Statistics grouped by media category
+
+    Attributes:
+        category (int | Unset): Media category (1=Anime, 2=Unknown, 3=J-Drama, 4=Audiobook) Example: 1.
+        count (int | Unset): Number of entries in this category Example: 1523.
+    """
+
+    category: int | Unset = UNSET
+    count: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        category = self.category
+
+        count = self.count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if category is not UNSET:
+            field_dict["category"] = category
+        if count is not UNSET:
+            field_dict["count"] = count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        category = d.pop("category", UNSET)
+
+        count = d.pop("count", UNSET)
+
+        category_statistic = cls(
+            category=category,
+            count=count,
+        )
+
+        category_statistic.additional_properties = d
+        return category_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/character.py

@@ -0,0 +1,100 @@
+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 import Seiyuu
+
+
+T = TypeVar("T", bound="Character")
+
+
+@_attrs_define
+class Character:
+    """Anime character
+
+    Attributes:
+        id (int): AniList character ID Example: 14545.
+        name_japanese (str): Japanese name of the character Example: 真城最高.
+        name_english (str): English name of the character Example: Moritaka Mashiro.
+        image_url (str): Character image URL Example: https://s4.anilist.co/file/anilistcdn/character/large/b14545.jpg.
+        seiyuu (Seiyuu): Japanese voice actor (seiyuu)
+    """
+
+    id: int
+    name_japanese: str
+    name_english: str
+    image_url: str
+    seiyuu: Seiyuu
+    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
+
+        seiyuu = self.seiyuu.to_dict()
+
+        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,
+                "seiyuu": seiyuu,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.seiyuu import Seiyuu
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name_japanese = d.pop("nameJapanese")
+
+        name_english = d.pop("nameEnglish")
+
+        image_url = d.pop("imageUrl")
+
+        seiyuu = Seiyuu.from_dict(d.pop("seiyuu"))
+
+        character = cls(
+            id=id,
+            name_japanese=name_japanese,
+            name_english=name_english,
+            image_url=image_url,
+            seiyuu=seiyuu,
+        )
+
+        character.additional_properties = d
+        return character
+
+    @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/character_input.py

@@ -0,0 +1,130 @@
+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 ..models.character_input_character_role import CharacterInputCharacterRole
+
+T = TypeVar("T", bound="CharacterInput")
+
+
+@_attrs_define
+class CharacterInput:
+    """Character data for creating/updating media
+
+    Attributes:
+        character_id (int): AniList character ID Example: 14545.
+        character_name_japanese (str): Japanese name of the character Example: 真城最高.
+        character_name_english (str): English name of the character Example: Moritaka Mashiro.
+        character_image_url (str): Character image URL Example:
+            https://s4.anilist.co/file/anilistcdn/character/large/b14545.jpg.
+        character_role (CharacterInputCharacterRole): Character's role in the media Example: MAIN.
+        seiyuu_id (int): AniList staff ID for the Japanese voice actor Example: 95991.
+        seiyuu_name_japanese (str): Japanese name of the voice actor Example: 阿部敦.
+        seiyuu_name_english (str): English name of the voice actor Example: Atsushi Abe.
+        seiyuu_image_url (str): Voice actor profile image URL Example:
+            https://s4.anilist.co/file/anilistcdn/staff/large/n95991.jpg.
+    """
+
+    character_id: int
+    character_name_japanese: str
+    character_name_english: str
+    character_image_url: str
+    character_role: CharacterInputCharacterRole
+    seiyuu_id: int
+    seiyuu_name_japanese: str
+    seiyuu_name_english: str
+    seiyuu_image_url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        character_id = self.character_id
+
+        character_name_japanese = self.character_name_japanese
+
+        character_name_english = self.character_name_english
+
+        character_image_url = self.character_image_url
+
+        character_role = self.character_role.value
+
+        seiyuu_id = self.seiyuu_id
+
+        seiyuu_name_japanese = self.seiyuu_name_japanese
+
+        seiyuu_name_english = self.seiyuu_name_english
+
+        seiyuu_image_url = self.seiyuu_image_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "characterId": character_id,
+                "characterNameJapanese": character_name_japanese,
+                "characterNameEnglish": character_name_english,
+                "characterImageUrl": character_image_url,
+                "characterRole": character_role,
+                "seiyuuId": seiyuu_id,
+                "seiyuuNameJapanese": seiyuu_name_japanese,
+                "seiyuuNameEnglish": seiyuu_name_english,
+                "seiyuuImageUrl": seiyuu_image_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        character_id = d.pop("characterId")
+
+        character_name_japanese = d.pop("characterNameJapanese")
+
+        character_name_english = d.pop("characterNameEnglish")
+
+        character_image_url = d.pop("characterImageUrl")
+
+        character_role = CharacterInputCharacterRole(d.pop("characterRole"))
+
+        seiyuu_id = d.pop("seiyuuId")
+
+        seiyuu_name_japanese = d.pop("seiyuuNameJapanese")
+
+        seiyuu_name_english = d.pop("seiyuuNameEnglish")
+
+        seiyuu_image_url = d.pop("seiyuuImageUrl")
+
+        character_input = cls(
+            character_id=character_id,
+            character_name_japanese=character_name_japanese,
+            character_name_english=character_name_english,
+            character_image_url=character_image_url,
+            character_role=character_role,
+            seiyuu_id=seiyuu_id,
+            seiyuu_name_japanese=seiyuu_name_japanese,
+            seiyuu_name_english=seiyuu_name_english,
+            seiyuu_image_url=seiyuu_image_url,
+        )
+
+        character_input.additional_properties = d
+        return character_input
+
+    @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/character_input_character_role.py

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

nadeshiko/models/character_with_media.py

@@ -0,0 +1,124 @@
+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.character_with_media_media_appearances_item import (
+        CharacterWithMediaMediaAppearancesItem,
+    )
+    from ..models.seiyuu import Seiyuu
+
+
+T = TypeVar("T", bound="CharacterWithMedia")
+
+
+@_attrs_define
+class CharacterWithMedia:
+    """Character with all media appearances
+
+    Attributes:
+        id (int): AniList character ID Example: 14545.
+        name_japanese (str): Japanese name of the character Example: 真城最高.
+        name_english (str): English name of the character Example: Moritaka Mashiro.
+        image_url (str): Character image URL Example: https://s4.anilist.co/file/anilistcdn/character/large/b14545.jpg.
+        seiyuu (Seiyuu): Japanese voice actor (seiyuu)
+        media_appearances (list[CharacterWithMediaMediaAppearancesItem]): All media this character appears in
+    """
+
+    id: int
+    name_japanese: str
+    name_english: str
+    image_url: str
+    seiyuu: Seiyuu
+    media_appearances: list[CharacterWithMediaMediaAppearancesItem]
+    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
+
+        seiyuu = self.seiyuu.to_dict()
+
+        media_appearances = []
+        for media_appearances_item_data in self.media_appearances:
+            media_appearances_item = media_appearances_item_data.to_dict()
+            media_appearances.append(media_appearances_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,
+                "seiyuu": seiyuu,
+                "mediaAppearances": media_appearances,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.character_with_media_media_appearances_item import (
+            CharacterWithMediaMediaAppearancesItem,
+        )
+        from ..models.seiyuu import Seiyuu
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name_japanese = d.pop("nameJapanese")
+
+        name_english = d.pop("nameEnglish")
+
+        image_url = d.pop("imageUrl")
+
+        seiyuu = Seiyuu.from_dict(d.pop("seiyuu"))
+
+        media_appearances = []
+        _media_appearances = d.pop("mediaAppearances")
+        for media_appearances_item_data in _media_appearances:
+            media_appearances_item = CharacterWithMediaMediaAppearancesItem.from_dict(
+                media_appearances_item_data
+            )
+
+            media_appearances.append(media_appearances_item)
+
+        character_with_media = cls(
+            id=id,
+            name_japanese=name_japanese,
+            name_english=name_english,
+            image_url=image_url,
+            seiyuu=seiyuu,
+            media_appearances=media_appearances,
+        )
+
+        character_with_media.additional_properties = d
+        return character_with_media
+
+    @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/character_with_media_media_appearances_item.py

@@ -0,0 +1,93 @@
+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.character_with_media_media_appearances_item_role import (
+    CharacterWithMediaMediaAppearancesItemRole,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.media import Media
+
+
+T = TypeVar("T", bound="CharacterWithMediaMediaAppearancesItem")
+
+
+@_attrs_define
+class CharacterWithMediaMediaAppearancesItem:
+    """
+    Attributes:
+        media (Media | Unset): Media entry with full metadata
+        role (CharacterWithMediaMediaAppearancesItemRole | Unset): Character role in this media Example: MAIN.
+    """
+
+    media: Media | Unset = UNSET
+    role: CharacterWithMediaMediaAppearancesItemRole | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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 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.media import Media
+
+        d = dict(src_dict)
+        _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: CharacterWithMediaMediaAppearancesItemRole | Unset
+        if isinstance(_role, Unset):
+            role = UNSET
+        else:
+            role = CharacterWithMediaMediaAppearancesItemRole(_role)
+
+        character_with_media_media_appearances_item = cls(
+            media=media,
+            role=role,
+        )
+
+        character_with_media_media_appearances_item.additional_properties = d
+        return character_with_media_media_appearances_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/character_with_media_media_appearances_item_role.py

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

nadeshiko/models/create_api_key_request.py

@@ -0,0 +1,75 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateApiKeyRequest")
+
+
+@_attrs_define
+class CreateApiKeyRequest:
+    """Create API key request
+
+    Attributes:
+        name (str): Name for the API key
+        permissions (list[str] | Unset): List of permissions for the API key. Defaults to READ_MEDIA if not provided.
+    """
+
+    name: str
+    permissions: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        permissions: list[str] | Unset = UNSET
+        if not isinstance(self.permissions, Unset):
+            permissions = self.permissions
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if permissions is not UNSET:
+            field_dict["permissions"] = permissions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        permissions = cast(list[str], d.pop("permissions", UNSET))
+
+        create_api_key_request = cls(
+            name=name,
+            permissions=permissions,
+        )
+
+        create_api_key_request.additional_properties = d
+        return create_api_key_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/create_api_key_response.py

@@ -0,0 +1,70 @@
+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="CreateApiKeyResponse")
+
+
+@_attrs_define
+class CreateApiKeyResponse:
+    """Create API key response
+
+    Attributes:
+        message (str): Success message
+        key (str): The generated API key (only shown once)
+    """
+
+    message: str
+    key: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        key = self.key
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "message": message,
+                "key": key,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        message = d.pop("message")
+
+        key = d.pop("key")
+
+        create_api_key_response = cls(
+            message=message,
+            key=key,
+        )
+
+        create_api_key_response.additional_properties = d
+        return create_api_key_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