nadeshiko-sdk 0.1.0__py3-none-any.whl

nadeshiko/models/user_info_response_user.py

@@ -0,0 +1,91 @@
+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.user_role import UserRole
+
+
+T = TypeVar("T", bound="UserInfoResponseUser")
+
+
+@_attrs_define
+class UserInfoResponseUser:
+    """
+    Attributes:
+        username (str): User's display name
+        email (str): User's email address
+        roles (list[UserRole]): User's roles
+    """
+
+    username: str
+    email: str
+    roles: list[UserRole]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        username = self.username
+
+        email = self.email
+
+        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(
+            {
+                "username": username,
+                "email": email,
+                "roles": roles,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.user_role import UserRole
+
+        d = dict(src_dict)
+        username = d.pop("username")
+
+        email = d.pop("email")
+
+        roles = []
+        _roles = d.pop("roles")
+        for roles_item_data in _roles:
+            roles_item = UserRole.from_dict(roles_item_data)
+
+            roles.append(roles_item)
+
+        user_info_response_user = cls(
+            username=username,
+            email=email,
+            roles=roles,
+        )
+
+        user_info_response_user.additional_properties = d
+        return user_info_response_user
+
+    @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/user_role.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="UserRole")
+
+
+@_attrs_define
+class UserRole:
+    """User role information
+
+    Attributes:
+        id_role (int | Unset): Role ID
+        name (str | Unset): Role name
+    """
+
+    id_role: int | Unset = UNSET
+    name: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id_role = self.id_role
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if id_role is not UNSET:
+            field_dict["id_role"] = id_role
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id_role = d.pop("id_role", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        user_role = cls(
+            id_role=id_role,
+            name=name,
+        )
+
+        user_role.additional_properties = d
+        return user_role
+
+    @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/word_match.py

@@ -0,0 +1,107 @@
+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.word_match_media import WordMatchMedia
+
+
+T = TypeVar("T", bound="WordMatch")
+
+
+@_attrs_define
+class WordMatch:
+    """Word matching result with occurrences across media
+
+    Attributes:
+        word (str | Unset): The word that was searched for Example: 彼女.
+        is_match (bool | Unset): Indicates whether the word was found in any segment Example: True.
+        total_matches (int | Unset): Total number of times this word appears across all media Example: 1523.
+        media (list[WordMatchMedia] | Unset): List of media containing this word
+    """
+
+    word: str | Unset = UNSET
+    is_match: bool | Unset = UNSET
+    total_matches: int | Unset = UNSET
+    media: list[WordMatchMedia] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        word = self.word
+
+        is_match = self.is_match
+
+        total_matches = self.total_matches
+
+        media: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.media, Unset):
+            media = []
+            for media_item_data in self.media:
+                media_item = media_item_data.to_dict()
+                media.append(media_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if word is not UNSET:
+            field_dict["word"] = word
+        if is_match is not UNSET:
+            field_dict["is_match"] = is_match
+        if total_matches is not UNSET:
+            field_dict["total_matches"] = total_matches
+        if media is not UNSET:
+            field_dict["media"] = media
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.word_match_media import WordMatchMedia
+
+        d = dict(src_dict)
+        word = d.pop("word", UNSET)
+
+        is_match = d.pop("is_match", UNSET)
+
+        total_matches = d.pop("total_matches", UNSET)
+
+        _media = d.pop("media", UNSET)
+        media: list[WordMatchMedia] | Unset = UNSET
+        if _media is not UNSET:
+            media = []
+            for media_item_data in _media:
+                media_item = WordMatchMedia.from_dict(media_item_data)
+
+                media.append(media_item)
+
+        word_match = cls(
+            word=word,
+            is_match=is_match,
+            total_matches=total_matches,
+            media=media,
+        )
+
+        word_match.additional_properties = d
+        return word_match
+
+    @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/word_match_media.py

@@ -0,0 +1,98 @@
+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="WordMatchMedia")
+
+
+@_attrs_define
+class WordMatchMedia:
+    """Media entry containing word matches
+
+    Attributes:
+        media_id (int | Unset): Unique identifier for the media Example: 110316.
+        english_name (str | Unset): English translation of the media name Example: Steins;Gate.
+        japanese_name (str | Unset): Original Japanese name of the media Example: シュタインズ・ゲート.
+        romaji_name (str | Unset): Romaji transliteration of the media name Example: Steins;Gate.
+        matches (int | Unset): Number of times the word appears in this media Example: 234.
+    """
+
+    media_id: int | Unset = UNSET
+    english_name: str | Unset = UNSET
+    japanese_name: str | Unset = UNSET
+    romaji_name: str | Unset = UNSET
+    matches: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        media_id = self.media_id
+
+        english_name = self.english_name
+
+        japanese_name = self.japanese_name
+
+        romaji_name = self.romaji_name
+
+        matches = self.matches
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if media_id is not UNSET:
+            field_dict["media_id"] = media_id
+        if english_name is not UNSET:
+            field_dict["english_name"] = english_name
+        if japanese_name is not UNSET:
+            field_dict["japanese_name"] = japanese_name
+        if romaji_name is not UNSET:
+            field_dict["romaji_name"] = romaji_name
+        if matches is not UNSET:
+            field_dict["matches"] = matches
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        media_id = d.pop("media_id", UNSET)
+
+        english_name = d.pop("english_name", UNSET)
+
+        japanese_name = d.pop("japanese_name", UNSET)
+
+        romaji_name = d.pop("romaji_name", UNSET)
+
+        matches = d.pop("matches", UNSET)
+
+        word_match_media = cls(
+            media_id=media_id,
+            english_name=english_name,
+            japanese_name=japanese_name,
+            romaji_name=romaji_name,
+            matches=matches,
+        )
+
+        word_match_media.additional_properties = d
+        return word_match_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/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, TypeVar
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
+    # (filename, file (or bytes), content_type)
+    tuple[str | None, FileContent, str | None]
+    # (filename, file (or bytes), content_type, headers)
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: str | None = None
+    mime_type: str | None = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T | None
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

nadeshiko_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: nadeshiko-sdk
+Version: 0.1.0
+Summary: Python SDK for Nadeshiko API
+Requires-Python: >=3.11
+Requires-Dist: attrs>=23.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: python-dateutil>=2.8.0
+Provides-Extra: dev
+Requires-Dist: openapi-python-client>=0.22.0; extra == 'dev'
+Requires-Dist: pytest>=9.0.0; extra == 'dev'
+Requires-Dist: pyyaml>=6.0; extra == 'dev'
+Requires-Dist: ruff>=0.9.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+> This repository is still in WIP and not ready for production use
+
+# Nadeshiko Python SDK
+
+Python SDK for the [Nadeshiko API](https://nadeshiko.co)
+
+## Quick Start
+
+```python
+from nadeshiko import Nadeshiko, Environment
+from nadeshiko.api.search import search
+
+# Configure your client
+client = Nadeshiko(
+    api_key='your-api-key-here',
+    base_url=Environment.PRODUCTION,  # or Environment.LOCAL, or custom URL
+)
+
+# Use API methods (names match OpenAPI operationIds)
+result = search.sync(
+    client=client,
+    body={
+        'query': '彼女',
+        'limit': 10,
+    },
+)
+
+if isinstance(result, Error):
+    print(result.code, result.detail)
+else:
+    print(result.sentences)
+```
+
+## API Methods
+
+All methods are organized under `nadeshiko.api.{module}` and match the OpenAPI operationIds exactly:
+
+You can check the full specification from the [OpenAPI spec page](https://nadeshiko.co/api/v1/docs).
+
+## Error Handling
+
+All methods return a union type: `Response | Error | None`.
+
+**Check for errors:**
+```python
+from nadeshiko import Nadeshiko, Environment
+from nadeshiko.api.search import search
+from nadeshiko.models import Error
+
+client = Nadeshiko(api_key='your-api-key', base_url=Environment.PRODUCTION)
+result = search.sync(client=client, body={'query': '彼女'})
+
+if isinstance(result, Error):
+    # Error type is fully generated from OpenAPI spec
+    print(result.code)    # e.g., 'RATE_LIMIT_EXCEEDED'
+    print(result.title)   # e.g., 'Rate Limit Exceeded'
+    print(result.detail)  # Detailed message
+    print(result.status)  # HTTP status code
+else:
+    print(result.sentences)
+```
+
+In general, all SDK methods return typed errors generated from the OpenAPI spec:
+
+```python
+class Error:
+    code: str                 # e.g., 'RATE_LIMIT_EXCEEDED', 'AUTH_CREDENTIALS_INVALID'
+    title: str                # Short summary
+    detail: str               # Detailed explanation
+    status: int               # HTTP status code
+    type_: str | Unset        # URI to error documentation
+    instance: str | Unset     # Trace ID
+    errors: dict | Unset      # Validation errors
+```
+
+Handle each error independently based on the error code returned by the API.
+
+```python
+from nadeshiko import Nadeshiko, Environment
+from nadeshiko.api.search import search
+from nadeshiko.models import Error
+
+client = Nadeshiko(api_key='your-api-key')
+result = search.sync(client=client, body={'query': '彼女'})
+
+if isinstance(result, Error):
+    # All error fields are typed
+    match result.code:
+        case 'RATE_LIMIT_EXCEEDED':
+            print('Wait before retrying')
+        case 'AUTH_CREDENTIALS_INVALID':
+            print('Check your API key')
+        case 'VALIDATION_FAILED':
+            print('Field errors:', result.errors)
+        case _:
+            print(result.detail)
+```
+
+You can check the full list of errors codes for each endpoint from the [OpenAPI spec page](https://nadeshiko.co/api/v1/docs).
+
+## Type Support
+
+All types are auto-generated from the OpenAPI spec.
+
+```python
+from nadeshiko.models import (
+    SearchRequest,
+    SearchResponse,
+    Sentence,
+    MediaInfoData,
+)
+
+request: SearchRequest = {
+    'query': '彼女',
+    'limit': 10,
+}
+
+sentence: Sentence = {
+    'basic_info': { # ... },
+    'segment_info': { # ... },
+    'media_info': { # ... },
+}
+```
+
+## Examples
+
+See `examples/usage.py` for more usage examples.
+
+## References
+
+- [Nadeshiko Website](https://nadeshiko.co)
+- [API Documentation](https://nadeshiko.co/settings/api)