attenpy 0.1.0__py3-none-any.whl

attenpy/__init__.py

@@ -0,0 +1,8 @@
+from .client import Client
+from .ref import UserRef
+
+__version__ = "0.1.0"
+__all__ = [
+    "Client",
+    "UserRef",
+]

attenpy/client.py

@@ -0,0 +1,25 @@
+from .endpoints import PostEndpoint, UserEndpoint
+from .http import HTTPClient
+
+
+class Client:
+    def __init__(
+        self,
+        token: str | None = None,
+        base_url: str = "https://api.atten.win",
+    ):
+        self.base_url = base_url
+        self.http: HTTPClient = HTTPClient(self.base_url, token)
+
+        self.users = UserEndpoint(self)
+        self.posts = PostEndpoint(self)
+
+    async def close(self) -> None:
+        if self.http:
+            await self.http.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()

attenpy/endpoints/__init__.py

@@ -0,0 +1,4 @@
+from .posts import PostEndpoint
+from .users import UserEndpoint
+
+__all__ = ["UserEndpoint", "PostEndpoint"]

attenpy/endpoints/posts.py

@@ -0,0 +1,116 @@
+from typing import TYPE_CHECKING, AsyncIterator, Unpack
+
+from ..models import PartialPost, PartialUser, Post
+from ..pagination import (
+    PaginateOptions,
+    paginate,
+)
+from ..payloads import ParentsPostPayload
+from ..utils import int_or_none
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+
+class PostEndpoint:
+    def __init__(self, client: "Client"):
+        self.client = client
+
+    async def create(
+        self,
+        content: str,
+        quote: int | PartialPost | None = None,
+    ) -> Post:
+        return Post.model_validate(
+            (
+                await self.client.http.post(
+                    "/posts", json={"content": content, "quote": int_or_none(quote)}
+                )
+            ).data
+        )
+
+    async def get(self, post: int | PartialPost) -> Post:
+        return Post.model_validate(
+            (await self.client.http.get(f"/posts/{int(post)}")).data
+        )
+
+    async def reply(
+        self,
+        parent: int | PartialPost,
+        content: str,
+        quote: int | PartialPost | None = None,
+    ) -> Post:
+        return Post.model_validate(
+            (
+                await self.client.http.post(
+                    f"/posts/{int(parent)}/reply",
+                    json={"content": content, "quote": int_or_none(quote)},
+                )
+            ).data
+        )
+
+    async def delete(self, post: int | PartialPost):
+        await self.client.http.post(f"/posts/{int(post)}")
+
+    async def love(self, post: int | PartialPost):
+        await self.client.http.post(f"/posts/{int(post)}/love")
+
+    async def unlove(self, post: int | PartialPost):
+        await self.client.http.delete(f"/posts/{int(post)}/love")
+
+    async def bookmark(self, post: int | PartialPost):
+        await self.client.http.post(f"/posts/{int(post)}/bookmark")
+
+    async def unbookmark(self, post: int | PartialPost):
+        await self.client.http.delete(f"/posts/{int(post)}/bookmark")
+
+    async def repost(self, post: int | PartialPost) -> Post:
+        return Post.model_validate(
+            (await self.client.http.post(f"/posts/{int(post)}/repost")).data
+        )
+
+    async def unrepost(self, post: int | PartialPost):
+        await self.client.http.delete(f"/posts/{int(post)}/repost")
+
+    async def get_loves(
+        self, post: int | PartialPost, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[PartialUser]:
+        async for data in paginate(self.client.http, f"/posts/{int(post)}/loves", **kw):
+            yield PartialUser.model_validate(data)
+
+    async def get_history(
+        self, post: int | PartialPost, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(
+            self.client.http, f"/posts/{int(post)}/history", **kw
+        ):
+            yield Post.model_validate(data)
+
+    async def get_quotes(
+        self, post: int | PartialPost, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(
+            self.client.http, f"/posts/{int(post)}/quotes", **kw
+        ):
+            yield Post.model_validate(data)
+
+    async def get_replies(
+        self, post: int | PartialPost, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(
+            self.client.http, f"/posts/{int(post)}/replies", **kw
+        ):
+            yield Post.model_validate(data)
+
+    async def get_reposts(
+        self, post: int | PartialPost, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(
+            self.client.http, f"/posts/{int(post)}/reposts", **kw
+        ):
+            yield Post.model_validate(data)
+
+    async def get_parents(self, post: int | PartialPost) -> ParentsPostPayload:
+        return ParentsPostPayload.model_validate(
+            (await self.client.http.get(f"/posts/{int(post)}/parents")).data
+        )

attenpy/endpoints/users.py

@@ -0,0 +1,106 @@
+from types import EllipsisType
+from typing import TYPE_CHECKING, AsyncIterator, Unpack
+
+from ..models import Attachment, PartialPost, PartialUser, Post, User
+from ..pagination import (
+    PaginateOptions,
+    paginate,
+)
+from ..ref import UserRef
+from ..utils import int_or_none
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+
+class UserEndpoint:
+    def __init__(self, client: "Client"):
+        self.client = client
+
+    async def get(self, user: UserRef | str) -> User:
+        return User.model_validate((await self.client.http.get(f"/users/{user}")).data)
+
+    async def edit(
+        self,
+        user: UserRef | str,
+        *,
+        display_name: str | None | EllipsisType = ...,
+        bio: str | EllipsisType = ...,
+        icon: int | Attachment | None | EllipsisType = ...,
+        banner: int | Attachment | None | EllipsisType = ...,
+        pinned: int | PartialPost | None | EllipsisType = ...,
+    ) -> User:
+        payload = {}
+        if display_name is not ...:
+            payload["display_name"] = display_name
+        if bio is not ...:
+            payload["bio"] = bio
+        if icon is not ...:
+            payload["icon_id"] = int_or_none(icon)
+        if banner is not ...:
+            payload["banner_id"] = int_or_none(banner)
+        if pinned is not ...:
+            payload["pinned_id"] = int_or_none(pinned)
+        return User.model_validate(
+            (await self.client.http.patch(f"/users/{user}", json=payload)).data
+        )
+
+    async def follow(self, user: UserRef | str):
+        await self.client.http.post(f"/users/{user}/follow")
+
+    async def unfollow(self, user: UserRef | str):
+        await self.client.http.delete(f"/users/{user}/follow")
+
+    async def mute(self, user: UserRef | str):
+        await self.client.http.post(f"/users/{user}/mute")
+
+    async def unmute(self, user: UserRef | str):
+        await self.client.http.delete(f"/users/{user}/mute")
+
+    async def get_followers(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[PartialUser]:
+        async for data in paginate(self.client.http, f"/users/{user}/followers", **kw):
+            yield PartialUser.model_validate(data)
+
+    async def get_following(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[PartialUser]:
+        async for data in paginate(self.client.http, f"/users/{user}/following", **kw):
+            yield PartialUser.model_validate(data)
+
+    async def get_mutes(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[PartialUser]:
+        async for data in paginate(self.client.http, f"/users/{user}/mutes", **kw):
+            yield PartialUser.model_validate(data)
+
+    async def get_posts(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(self.client.http, f"/users/{user}/posts", **kw):
+            yield Post.model_validate(data)
+
+    async def get_medias(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(self.client.http, f"/users/{user}/medias", **kw):
+            yield Post.model_validate(data)
+
+    async def get_loves(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(self.client.http, f"/users/{user}/loves", **kw):
+            yield Post.model_validate(data)
+
+    async def get_bookmarks(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(self.client.http, f"/users/{user}/bookmarks", **kw):
+            yield Post.model_validate(data)
+
+    async def get_reposts(
+        self, user: UserRef | str, **kw: Unpack[PaginateOptions]
+    ) -> AsyncIterator[Post]:
+        async for data in paginate(self.client.http, f"/users/{user}/reposts", **kw):
+            yield Post.model_validate(data)

attenpy/exceptions.py

@@ -0,0 +1,13 @@
+from .types import ErrorResponsePayload
+
+
+class AttenpyException(Exception):
+    pass
+
+
+class HTTPException(AttenpyException):
+    def __init__(self, status: int, data: ErrorResponsePayload):
+        self.status = status
+        self.code = data["code"]
+        self.details = data["details"]
+        super().__init__(f"HTTP {self.status}: {self.code}")

attenpy/http.py

@@ -0,0 +1,78 @@
+from typing import Any, Optional, TypedDict, Unpack, cast
+
+import aiohttp
+
+from .exceptions import HTTPException
+from .models import ListResponse, SuccessResponse
+from .types import AnyResponsePayload
+
+
+class RequestOptions(TypedDict, total=False):
+    json: Any
+    params: dict[str, Any]
+
+
+class HTTPClient:
+    def __init__(self, base_url: str, token: str | None):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            headers = {}
+            if self.token:
+                headers["Authorization"] = "Bearer " + self.token
+            self._session = aiohttp.ClientSession(headers=headers)
+        return self._session
+
+    async def _request[T](
+        self, method: str, path: str, **kw: Unpack[RequestOptions]
+    ) -> Any:
+        if not path.startswith("/"):
+            raise ValueError()
+        session = await self._get_session()
+        url = self.base_url + path
+
+        async with session.request(
+            method, url, json=kw.get("json"), params=kw.get("params")
+        ) as resp:
+            data = cast(AnyResponsePayload, await resp.json())  # TODO レスポンスの検証
+            if data["ok"] is False:
+                raise HTTPException(resp.status, data)  # TODO statusごとにクラス分ける
+                # TODO 429
+        return data
+
+    async def get(self, path: str, **kw: Unpack[RequestOptions]) -> SuccessResponse:
+        data = await self._request("GET", path, **kw)
+        return SuccessResponse.from_json(data)
+
+    async def get_list(self, path: str, **kw: Unpack[RequestOptions]) -> ListResponse:
+        data = await self._request("GET", path, **kw)
+        return ListResponse.from_json(data)
+
+    async def post(self, path: str, **kw: Unpack[RequestOptions]) -> SuccessResponse:
+        data = await self._request("POST", path, **kw)
+        return SuccessResponse.from_json(data)
+
+    async def put(self, path: str, **kw: Unpack[RequestOptions]) -> SuccessResponse:
+        data = await self._request("PUT", path, **kw)
+        return SuccessResponse.from_json(data)
+
+    async def patch(self, path: str, **kw: Unpack[RequestOptions]) -> SuccessResponse:
+        data = await self._request("PATCH", path, **kw)
+        return SuccessResponse.from_json(data)
+
+    async def delete(self, path: str, **kw: Unpack[RequestOptions]) -> SuccessResponse:
+        data = await self._request("DELETE", path, **kw)
+        return SuccessResponse.from_json(data)
+
+    async def close(self) -> None:
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()

attenpy/models/__init__.py

@@ -0,0 +1,21 @@
+from .attachment import Attachment, ExternalAttachment
+from .base import CursorPage, ListResponse, SuccessResponse
+from .post import PartialPost, Post
+from .user import PartialUser, User
+
+PartialPost.model_rebuild()
+Post.model_rebuild()
+PartialUser.model_rebuild()
+User.model_rebuild()
+
+__all__ = [
+    "Attachment",
+    "CursorPage",
+    "ExternalAttachment",
+    "ListResponse",
+    "PartialPost",
+    "PartialUser",
+    "Post",
+    "SuccessResponse",
+    "User",
+]

attenpy/models/attachment.py

@@ -0,0 +1,20 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class Attachment(BaseModel):
+    id: int
+    url: str
+    category: Literal[
+        "icon", "banner", "post_attachment", "group_icon", "chat_attachment"
+    ]
+    mime: str
+    deleted: bool
+
+    def __int__(self) -> int:
+        return self.id
+
+
+class ExternalAttachment(BaseModel):
+    url: str

attenpy/models/base.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from typing import Generic, Self, TypeVar
+
+from ..types import (
+    CursorPagePayload,
+    ListResponsePayload,
+    RequestMetaPayload,
+    SuccessResponsePayload,
+)
+from ..utils import int_or_none
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True, slots=True)
+class RequestMeta:
+    request_id: str
+    session_id: int | None
+    actor_id: int | None
+
+    @classmethod
+    def from_json(cls, data: RequestMetaPayload) -> Self:
+        return cls(
+            data["request_id"],
+            int_or_none(data["session_id"]),
+            int_or_none(data["actor_id"]),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class SuccessResponse(Generic[T]):
+    ok: bool
+    meta: RequestMeta
+    data: T
+
+    @classmethod
+    def from_json(cls, data: SuccessResponsePayload) -> Self:
+        return cls(
+            data["ok"],
+            RequestMeta.from_json(data["meta"]),
+            data["data"],
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class CursorPage:
+    limit: int
+    order: str
+    cursor: int | None
+    next: int | None
+    back: int | None
+    has_more: bool
+
+    @classmethod
+    def from_json(cls, data: CursorPagePayload) -> Self:
+        return cls(
+            data["limit"],
+            data["order"],
+            int_or_none(data["cursor"]),
+            int_or_none(data["next"]),
+            int_or_none(data["back"]),
+            data["has_more"],
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ListResponse(Generic[T]):
+    ok: bool
+    meta: RequestMeta
+    data: list[T]
+    page: CursorPage
+
+    @classmethod
+    def from_json(cls, data: ListResponsePayload) -> Self:
+        return cls(
+            data["ok"],
+            RequestMeta.from_json(data["meta"]),
+            data["data"],
+            CursorPage.from_json(data["page"]),
+        )

attenpy/models/post.py

@@ -0,0 +1,41 @@
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .attachment import Attachment
+    from .user import PartialUser
+
+
+class PartialPost(BaseModel):
+    id: int
+    author_id: str
+    author: "PartialUser"
+    content_md: str
+    parent_id: str | None
+    target_history_id: str | None
+    current_history_id: str
+    quote_id: str | None
+    root_id: str | None
+    is_repost: bool
+    is_edited: bool
+    deleted: bool
+    attachments: list["Attachment"]
+
+    def __int__(self) -> int:
+        return self.id
+
+
+class Post(PartialPost):
+    parent: PartialPost | None
+    quote: PartialPost | None
+    love_count: int
+    bookmark_count: int
+    reply_count: int
+    quote_count: int
+    is_loved: bool | None
+    is_bookmarked: bool | None
+    is_reposted: bool | None
+    target: "Post | None" = None
+    version: int | None = None
+    is_latest: bool = True

attenpy/models/user.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from ..ref import UserRef
+
+if TYPE_CHECKING:
+    from .attachment import Attachment, ExternalAttachment
+    from .post import Post
+
+
+class PartialUser(BaseModel):
+    id: int
+    scratch_name: str
+    display_name: str | None
+    icon: "Attachment | ExternalAttachment"
+    public_flags: int  # TODO
+    deleted: bool
+    is_muted: bool | None
+    is_following: bool | None = None
+    is_followed: bool | None = None
+
+    def __int__(self) -> int:
+        return self.id
+
+    @property
+    def ref(self):
+        return UserRef(user_id=self.id)
+
+
+class User(PartialUser):
+    scratch_id: int
+    bio: str
+    pinned: "Post | None"
+    followers_count: int
+    following_count: int
+    post_count: int
+    love_count: int

attenpy/pagination.py

@@ -0,0 +1,43 @@
+from collections.abc import AsyncIterator
+from typing import Any, Literal, TypedDict, TypeVar, Unpack
+
+from .http import HTTPClient
+
+ItemT = TypeVar("ItemT")
+CursorT = TypeVar("CursorT")
+
+MAX_PAGINATION_LIMIT = 30
+
+PAGINATE_ORDER = Literal["desc", "asc"]
+PAGINATE_ORDER_DEFAULT: PAGINATE_ORDER = "desc"
+
+
+class PaginateOptions(TypedDict, total=False):
+    cursor: int
+    limit: int
+    order: PAGINATE_ORDER
+
+
+async def paginate(
+    http: HTTPClient,
+    path: str,
+    *,
+    params: dict[str, Any] | None = None,
+    **kw: Unpack[PaginateOptions],
+) -> AsyncIterator:
+    params = (params and params.copy()) or {}
+    params["order"] = kw.get("order", PAGINATE_ORDER_DEFAULT)
+    if "cursor" in kw:
+        params["cursor"] = kw["cursor"]
+    remaining = kw.get("limit", MAX_PAGINATION_LIMIT)
+    while remaining > 0:
+        params["limit"] = min(remaining, MAX_PAGINATION_LIMIT)
+        resp = await http.get_list(path, params=params)
+        for item in resp.data:
+            yield item
+            remaining -= 1
+            if remaining == 0:
+                return
+        if not resp.page.has_more:
+            break
+        params["cursor"] = resp.page.next

attenpy/payloads/__init__.py

@@ -0,0 +1,3 @@
+from .post import ParentsPostPayload
+
+__all__ = ["ParentsPostPayload"]

attenpy/payloads/post.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+from ..models import Post
+
+
+class ParentsPostPayload(BaseModel):
+    root: Post | None
+    parents: list[Post]
+    next_id: int | None

attenpy/ref.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+from typing import ClassVar, Literal, Union
+
+
+@dataclass(frozen=True, kw_only=True)
+class UserRef:
+    user_id: int | None = None
+    username: str | None = None
+    me: Literal[True] | None = None
+
+    ME: ClassVar["UserRef"]
+
+    def __str__(self) -> str:
+        match self.value:
+            case "username", username:
+                return username
+            case "user_id", user_id:
+                return f":{user_id}"
+            case "me", _:
+                return ":me"
+        raise ValueError()
+
+    def __post_init__(self):
+        if sum(i is not None for i in (self.username, self.user_id, self.me)) != 1:
+            raise ValueError
+
+    @property
+    def value(
+        self,
+    ) -> Union[
+        tuple[Literal["username"], str],
+        tuple[Literal["user_id"], int],
+        tuple[Literal["me"], Literal[True]],
+    ]:
+        if self.username is not None:
+            return "username", self.username
+        elif self.user_id is not None:
+            return "user_id", self.user_id
+        elif self.me is not None:
+            return "me", self.me
+        raise ValueError
+
+    @classmethod
+    def from_str(cls, path: str):
+        if path.startswith(":"):
+            user_id = path[1:]
+            if user_id == "me":
+                return cls(me=True)
+            if user_id.isdecimal():
+                return cls(user_id=int(user_id))
+        return cls(username=path)
+
+
+UserRef.ME = UserRef(me=True)

attenpy/types.py

@@ -0,0 +1,35 @@
+from typing import Any, Literal, TypedDict
+
+
+class RequestMetaPayload(TypedDict):
+    request_id: str
+    session_id: str | None
+    actor_id: str | None
+
+
+class SuccessResponsePayload[T](TypedDict):
+    ok: Literal[True]
+    data: T
+    meta: RequestMetaPayload
+
+
+class CursorPagePayload(TypedDict):
+    limit: int
+    order: Literal["asc", "desc"]
+    cursor: str | None
+    next: str | None
+    back: str | None
+    has_more: bool
+
+
+class ListResponsePayload[T](SuccessResponsePayload[list[T]]):
+    page: CursorPagePayload
+
+
+class ErrorResponsePayload(TypedDict):
+    ok: Literal[False]
+    code: str
+    details: dict[str, Any]
+
+
+AnyResponsePayload = SuccessResponsePayload | ErrorResponsePayload

attenpy/utils.py

@@ -0,0 +1,5 @@
+from typing import Any
+
+
+def int_or_none(obj: Any) -> int | None:
+    return None if obj is None else int(obj)

attenpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: attenpy
+Version: 0.1.0
+Summary: SDK for AttenAPI
+Author: AttenTeam
+License: MIT
+Project-URL: Homepage, https://atten.win/
+Project-URL: Repository, https://github.com/attensns/attenpy
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# attenpy
+
+attenAPIツール

attenpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+attenpy/__init__.py,sha256=A09L8Rvu_cxinq-QV1ljMR-7OLh6k4IPV0MkL6cQ9Dc,118
+attenpy/client.py,sha256=eIP5OEC9-ExqZGaIwlZ2Jmoz3QJe9O93HofIoIkPfVo,621
+attenpy/exceptions.py,sha256=d_3CvXnaAK-Fz9ltWMBAmC1EZRMXHW90zgn40gWijHs,354
+attenpy/http.py,sha256=melMmaROj23WSVEcIHysZ0X4K7H2DLGyXH7KH7QgSOM,2887
+attenpy/pagination.py,sha256=kEhsL7p55RtoNLhSfSA0dSunqVTwrG5iNdFMhlVv3VQ,1171
+attenpy/ref.py,sha256=P30_abZZMaJGWO9mhFq0qunALKVpxsK4B8sxSHGh0oE,1473
+attenpy/types.py,sha256=LiO6ZIcOy_G6hCUholrva5jJUCC9SSGQIcamnzhtX0E,702
+attenpy/utils.py,sha256=POzFWt4ZFmDv5xZJUIlZZxZvnag4u82es6Wc9ZvnR3M,111
+attenpy/endpoints/__init__.py,sha256=Vw0HOM2fEREWWdp5DN6P4SxJdjcd9Ybc2m0SkISzCFQ,108
+attenpy/endpoints/posts.py,sha256=iiugty-Pk5SF497cawU9CcNCVehLbmHiKqDGJXRKNf0,3873
+attenpy/endpoints/users.py,sha256=j-dyhf9WS5SnYbMmm0ff0Zwf2L8agLPGPUyyDXLNyeo,3987
+attenpy/models/__init__.py,sha256=zjgISt9uomgiD_imjAagQ23FT2Pt93PDjtjThdk8BXs,468
+attenpy/models/attachment.py,sha256=dRjs9y4B_WR0Xdj1inWFn-ClViiFO22Ga1nkZIMNPeo,359
+attenpy/models/base.py,sha256=sP1nZbKQbBNuuVpI_SNrW0AhbYrFRiIXg98l87iFXac,1811
+attenpy/models/post.py,sha256=jOp3QYxZlSf7d0PsMDaTurKXxe_5rZfEalSzewP41Y8,902
+attenpy/models/user.py,sha256=BFFdkbx8NuSDd-HRCFhEzUtag7fUZLcww9ylKSAe2i0,787
+attenpy/payloads/__init__.py,sha256=mRuAe8ln_t9gdw8PxhnQRXMgNgyXKVz_0jY1J1ZSdtI,71
+attenpy/payloads/post.py,sha256=IsNxxlXZaKxCpypFDlrkpo2PSRKLFXN6Pocd08i2T64,167
+attenpy-0.1.0.dist-info/licenses/LICENSE,sha256=vJL8eExltbXjraffK8-IjNYygq-AE8jF_8H6-Z7ixAk,1066
+attenpy-0.1.0.dist-info/METADATA,sha256=AgaEVw_g6coB1OPV_gdM2DQ2hax779s75T9wHiEiv34,529
+attenpy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+attenpy-0.1.0.dist-info/top_level.txt,sha256=L2dDUmZB6ZIBxs8GUQVfbiEgVsTn1HUzk-8pTrrWJpc,8
+attenpy-0.1.0.dist-info/RECORD,,

attenpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

attenpy-0.1.0.dist-info/licenses/LICENSE

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

attenpy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+attenpy