spoonbot 0.1.0__py3-none-any.whl

spoonbot/__init__.py

@@ -0,0 +1,25 @@
+from spoonbot.db.config.MySQLConfig import MySQLConfig
+from spoonbot.dto.event.ChatEvent import ChatEvent
+from spoonbot.dto.event.ConnectEvent import ConnectEvent
+from spoonbot.dto.event.DonationEvent import GiftEvent
+from spoonbot.dto.event.EndEvent import EndEvent
+from spoonbot.dto.event.FollowEvent import FollowEvent
+from spoonbot.dto.event.JoinEvent import JoinEvent
+from spoonbot.dto.event.LikeEvent import LikeEvent
+from spoonbot.enums.Country import Country
+from spoonbot.enums.SpoonPermission import SpoonPermission
+from spoonbot.spoon_bot import SpoonBot
+
+__all__ = [
+    "MySQLConfig",
+    "ChatEvent",
+    "ConnectEvent",
+    "GiftEvent",
+    "EndEvent",
+    "FollowEvent",
+    "JoinEvent",
+    "LikeEvent",
+    "Country",
+    "SpoonPermission",
+    "SpoonBot",
+]

spoonbot/config/ConstantsConfig.py

@@ -0,0 +1,21 @@
+from typing import Self
+
+from spoonbot.constants import (
+    API_BASE_URL_JP,
+    API_BASE_URL_KR,
+    OAUTH_AUTHORIZE_BASE_URL_JP,
+    OAUTH_AUTHORIZE_BASE_URL_KR,
+)
+from spoonbot.enums.Country import Country
+
+
+class ConstantsConfig:
+    def __init__(self, oauth_authorize_base_url: str, api_base_url: str) -> None:
+        self.oauth_authorize_base_url = oauth_authorize_base_url
+        self.api_base_url = api_base_url
+
+    @classmethod
+    def create(cls, country: Country) -> Self:
+        if country == Country.KR:
+            return cls(OAUTH_AUTHORIZE_BASE_URL_KR, API_BASE_URL_KR)
+        return cls(OAUTH_AUTHORIZE_BASE_URL_JP, API_BASE_URL_JP)

spoonbot/constants.py

@@ -0,0 +1,12 @@
+OAUTH_AUTHORIZE_BASE_URL_KR = "https://developers.spooncast.net/kr/oauth/authorize"
+OAUTH_AUTHORIZE_BASE_URL_JP = "https://developers.spooncast.net/jp/oauth/authorize"
+
+API_BASE_URL_KR = "https://kr-openapi.spooncast.net/v1/"
+API_BASE_URL_JP = "https://jp-openapi.spooncast.net/v1/"
+
+SPACE = " "
+# https://developers.spooncast.net/docs/en/api-reference/tokens
+DEFAULT_REFRESH_TOKEN_EXPIRES_IN = 60 * 60 * 24 * 30  # 30 days
+DEFAULT_SESSION_EXPIRES_IN = (
+    DEFAULT_REFRESH_TOKEN_EXPIRES_IN - 60 * 15
+)  # 29 days 23 hour 45 minutes

spoonbot/controller/SpoonBotController.py

@@ -0,0 +1,56 @@
+from aiohttp.web_exceptions import HTTPForbidden, HTTPUnauthorized
+from aiohttp.web_request import Request
+from aiohttp.web_response import Response, json_response
+from aiohttp.web_routedef import RouteTableDef
+
+from spoonbot.spoon_bot import SpoonBot
+
+routes = RouteTableDef()
+
+
+class SpoonBotController:
+    spoon_bot: SpoonBot
+
+    def __init__(self, spoon_bot: SpoonBot) -> None:
+        self.spoon_bot = spoon_bot
+
+        routes.get("/api/v1/csrf-token")(self.csrf_token_function())
+        routes.get("/api/v1/bot")(self.bot_information_function())
+        routes.post("/api/v1/bot/invite")(self.bot_invite_request_handler())
+
+    def csrf_token_function(self):
+        async def csrf_token_handler(request: Request) -> Response:
+            session_id = request.cookies.get("session_id")
+            if session_id is None:
+                raise HTTPUnauthorized()
+            csrf_token = await self.spoon_bot.regenerate_csrf_token(session_id)
+            return json_response({"csrf_token": csrf_token})
+
+        return csrf_token_handler
+
+    def bot_information_function(self):
+        async def bot_information_handler(_: Request) -> Response:
+            page = self.spoon_bot.get_bot_operation_page()
+            return json_response(
+                {"bot_name": self.spoon_bot.get_bot_name(), "page": page}
+            )
+
+        return bot_information_handler
+
+    def bot_invite_request_handler(self):
+        async def bot_invite_request(request: Request) -> Response:
+            session_id = request.cookies.get("session_id")
+            csrf_token = request.headers.get("X-CSRF-TOKEN")
+            if session_id is None:
+                raise HTTPUnauthorized()
+            if csrf_token is None:
+                raise HTTPForbidden(reason="Bad Request. Need X-CSRF-TOKEN")
+            result = await self.spoon_bot.start_stream_by_session(
+                session_id, csrf_token
+            )
+            return Response(status=204 if result else 409)
+
+        return bot_invite_request
+
+    def get_route(self) -> RouteTableDef:
+        return routes

spoonbot/controller/SpoonBotWebController.py

@@ -0,0 +1,52 @@
+import sys
+from pathlib import Path
+
+from aiohttp.web_exceptions import HTTPNotFound
+from aiohttp.web_fileresponse import FileResponse
+from aiohttp.web_request import Request
+from aiohttp.web_response import StreamResponse
+from aiohttp.web_routedef import RouteTableDef
+
+routes = RouteTableDef()
+
+
+def _get_base_dir() -> Path:
+    # PyInstaller などで実行ファイル化されている場合
+    meipass = getattr(sys, "_MEIPASS", None)
+    if meipass is not None:
+        return Path(meipass)
+
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable).resolve().parent
+
+    # src/controller/xxx.py
+    return Path(__file__).resolve().parents[3]
+
+
+PAGES = {
+    "connect": "connect.html",
+    "success": "success.html",
+    "fail": "fail.html",
+    "invite": "invite.html",
+}
+ASSETS_DIR = _get_base_dir() / "assets"
+
+
+class SpoonBotWebController:
+    def __init__(self) -> None:
+        for page in PAGES:
+            routes.get(f"/spoonbot/{page}")(self.serve_page)
+        routes.static("/assets/", ASSETS_DIR)
+
+    @staticmethod
+    async def serve_page(request: Request) -> StreamResponse:
+        filename = PAGES[request.path[len("/spoonbot/") :]]
+        filepath = ASSETS_DIR / filename
+
+        if not filepath.is_file():
+            raise HTTPNotFound()
+
+        return FileResponse(filepath)
+
+    def get_route(self) -> RouteTableDef:
+        return routes

spoonbot/controller/SpoonOAuthController.py

@@ -0,0 +1,76 @@
+import logging
+
+from aiohttp.web_exceptions import HTTPFound
+from aiohttp.web_request import Request
+from aiohttp.web_routedef import RouteTableDef
+
+from spoonbot.constants import DEFAULT_SESSION_EXPIRES_IN
+from spoonbot.spoon_bot import SpoonBot
+
+routes = RouteTableDef()
+SIGNED_STATE_KEY = "signed_state"
+logger = logging.getLogger(__name__)
+
+
+class SpoonOAuthController:
+    spoon_bot: SpoonBot
+
+    def __init__(self, spoon_bot: SpoonBot) -> None:
+        self.spoon_bot = spoon_bot
+
+        routes.get("/oauth")(self.redirect_authorization_url_handler())
+        routes.get("/oauth/callback")(self.get_token_via_oauth_handler())
+
+    def redirect_authorization_url_handler(self):
+        async def redirect_authorization_url(_: Request) -> HTTPFound:
+            authorize_url = self.spoon_bot.user_authorize_url()
+            response = HTTPFound(location=authorize_url.url)
+
+            response.set_cookie(
+                name=SIGNED_STATE_KEY,
+                value=authorize_url.state,
+                max_age=60 * 3,  # 3分有効
+                httponly=True,
+                samesite="Lax",
+                secure=True,
+            )
+
+            return response
+
+        return redirect_authorization_url
+
+    def get_token_via_oauth_handler(self):
+        async def get_token_via_oauth(request: Request):
+            code = request.query.get("code")
+            signed_state = request.query.get("state")
+            cookie_state = request.cookies.get(SIGNED_STATE_KEY)
+
+            try:
+                auth = await self.spoon_bot.get_authorization(
+                    code, cookie_state, signed_state
+                )
+                await self.spoon_bot.save_authorization(auth)
+                session_id = await self.spoon_bot.save_session(auth)
+
+                response = HTTPFound(location="/spoonbot/success")
+                response.del_cookie(SIGNED_STATE_KEY)
+                response.set_cookie(
+                    name="session_id",
+                    value=session_id,
+                    max_age=DEFAULT_SESSION_EXPIRES_IN,
+                    httponly=True,
+                    samesite="Lax",
+                    secure=True,
+                )
+
+                return response
+            except Exception as exception:
+                logger.exception(exception)
+                response = HTTPFound(location="/spoonbot/fail")
+                response.del_cookie(SIGNED_STATE_KEY)
+                return response
+
+        return get_token_via_oauth
+
+    def get_route(self) -> RouteTableDef:
+        return routes

spoonbot/db/DBType.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+
+class DBType(StrEnum):
+    SQLITE3 = "SQLITE3"
+    MYSQL = "MYSQL"

spoonbot/db/DatabaseClient.py

@@ -0,0 +1,75 @@
+from abc import ABC, abstractmethod
+from contextlib import AbstractAsyncContextManager
+from typing import Any, LiteralString, TypeVar
+
+from spoonbot.db.config.MySQLConfig import MySQLConfig
+from spoonbot.db.DBType import DBType
+from spoonbot.db.types import DBValueType
+
+ResponseGenericType = TypeVar("ResponseGenericType")
+
+
+class DatabaseClient(ABC):
+    db_type: DBType
+
+    def __init__(self, db_type: DBType) -> None:
+        self.db_type = db_type
+
+    @classmethod
+    async def create(cls, config: MySQLConfig | None = None) -> "DatabaseClient":
+        # lazy import
+        from spoonbot.db.mysql.MySQLClient import MySQLClient
+        from spoonbot.db.sqlite3.Sqlite3Client import Sqlite3Client
+
+        if config is None:
+            client = Sqlite3Client(DBType.SQLITE3)
+            await client.initialize()
+            return client
+        client = MySQLClient(DBType.MYSQL)
+        await client.initialize(config)
+        return client
+
+    @abstractmethod
+    async def initialize(self, *args, **kwargs):
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+    @abstractmethod
+    async def execute_one(
+        self,
+        query: str,
+        args: dict[str, DBValueType] | None = None,
+        response_type: type[ResponseGenericType] | None = None,
+    ) -> ResponseGenericType | None:
+        pass
+
+    @abstractmethod
+    async def execute_many(
+        self,
+        query: str,
+        args: dict[str, DBValueType] | None = None,
+        response_type: type[ResponseGenericType] | None = None,
+    ) -> list[ResponseGenericType] | None:
+        pass
+
+    @abstractmethod
+    def transaction(self) -> AbstractAsyncContextManager[Any]:
+        pass
+
+    @abstractmethod
+    async def execute_cud(
+        self,
+        query: str,
+        args: dict[str, DBValueType] | None = None,
+    ) -> int:
+        pass
+
+    @abstractmethod
+    def placeholder(self, name: LiteralString) -> str:
+        pass
+
+    def get_db_type(self) -> DBType:
+        return self.db_type

spoonbot/db/SpoonUserRepository.py

@@ -0,0 +1,278 @@
+import time
+
+from spoonbot.db.config.MySQLConfig import MySQLConfig
+from spoonbot.db.DatabaseClient import DatabaseClient
+from spoonbot.db.DBType import DBType
+from spoonbot.db.dto.TokenDataDto import SessionDataDto, TokenDataDto
+
+
+class SpoonUserRepository:
+    database_client: DatabaseClient
+
+    async def initialize(self, config: MySQLConfig | None = None):
+        self.database_client = await DatabaseClient.create(config)
+        await self._create_table()
+
+    async def close(self):
+        await self.database_client.close()
+
+    async def _create_table(self):
+        if self.database_client.get_db_type() == DBType.MYSQL:
+            await self._create_table_for_mysql()
+        else:
+            await self._create_table_for_sqlite()
+
+    async def _create_table_for_mysql(self):
+        await self.database_client.execute_cud(
+            query="""-- sql
+              CREATE TABLE IF NOT EXISTS authorization_spoon_users (
+                  id VARCHAR(256) PRIMARY KEY,
+                  access_token VARCHAR(256) NOT NULL,
+                  refresh_token VARCHAR(256) NOT NULL,
+                  expire_at BIGINT,
+                  refresh_expire_at BIGINT,
+                  scope VARCHAR(512),
+                  token_type VARCHAR(32),
+                  token_status VARCHAR(32) DEFAULT "DEFAULT",
+                  
+                  created_at BIGINT NOT NULL, 
+                  updated_at BIGINT NOT NULL,
+                  
+                  INDEX idx_expire_at (expire_at),
+                  INDEX idx_refresh_expire_at (refresh_expire_at)
+              )
+            """
+        )
+        await self.database_client.execute_cud(
+            query="""-- sql
+              CREATE TABLE IF NOT EXISTS authorization_spoon_user_sessions (
+                  id BINARY(16) PRIMARY KEY,
+                  authorization_spoon_user_id VARCHAR(256) NOT NULL,
+                  encoded_session_id BINARY(32) NOT NULL,
+                  csrf_token VARCHAR(64),
+                  
+                  expires_at BIGINT NOT NULL, 
+                  created_at BIGINT NOT NULL, 
+                  updated_at BIGINT NOT NULL,
+                  FOREIGN KEY (authorization_spoon_user_id) 
+                      REFERENCES authorization_spoon_users(id),
+                  INDEX idx_encoded_session_id (encoded_session_id),
+                  INDEX idx_authorization_spoon_user_id (authorization_spoon_user_id)
+              )
+            """
+        )
+
+    async def _create_table_for_sqlite(self):
+        await self.database_client.execute_cud(
+            query="""-- sql
+              CREATE TABLE IF NOT EXISTS authorization_spoon_users (
+                  id VARCHAR(256) PRIMARY KEY,
+                  access_token VARCHAR(256) NOT NULL,
+                  refresh_token VARCHAR(256) NOT NULL,
+                  expire_at BIGINT,
+                  refresh_expire_at BIGINT,
+                  scope VARCHAR(512),
+                  token_type VARCHAR(32),
+                  token_status VARCHAR(32) DEFAULT "DEFAULT",
+                  
+                  created_at BIGINT NOT NULL, 
+                  updated_at BIGINT NOT NULL
+              )
+            """
+        )
+        await self.database_client.execute_cud(
+            """-- sql
+            CREATE INDEX IF NOT EXISTS idx_expire_at ON authorization_spoon_users(expire_at)
+            """  # noqa: E501
+        )
+        await self.database_client.execute_cud(
+            """-- sql
+            CREATE INDEX IF NOT EXISTS idx_refresh_expire_at ON authorization_spoon_users(refresh_expire_at)
+            """  # noqa: E501
+        )
+        await self.database_client.execute_cud(
+            query="""-- sql
+              CREATE TABLE IF NOT EXISTS authorization_spoon_user_sessions (
+                  id BINARY(16) PRIMARY KEY,
+                  authorization_spoon_user_id VARCHAR(256) NOT NULL,
+                  encoded_session_id BINARY(32) NOT NULL,
+                  csrf_token VARCHAR(64),
+                  
+                  expires_at BIGINT NOT NULL, 
+                  created_at BIGINT NOT NULL, 
+                  updated_at BIGINT NOT NULL,
+                  FOREIGN KEY (authorization_spoon_user_id) REFERENCES authorization_spoon_users(id)
+              )
+            """  # noqa: E501
+        )
+        await self.database_client.execute_cud(
+            """-- sql
+            CREATE INDEX IF NOT EXISTS idx_encoded_session_id ON authorization_spoon_user_sessions(encoded_session_id);
+            """  # noqa: E501
+        )
+
+        await self.database_client.execute_cud(
+            """-- sql
+            CREATE INDEX IF NOT EXISTS idx_authorization_spoon_user_id ON authorization_spoon_user_sessions(authorization_spoon_user_id);
+            """  # noqa: E501
+        )
+
+    async def insert_token(self, token: TokenDataDto) -> bool:
+        epoch_seconds = int(time.time())
+        result = await self.database_client.execute_cud(
+            query=f"""-- sql
+            INSERT INTO authorization_spoon_users(
+                id,
+                access_token,
+                refresh_token,
+                expire_at,
+                refresh_expire_at,
+                scope,
+                token_type,
+                created_at,
+                updated_at
+            ) VALUES(
+                {self.database_client.placeholder("id")},
+                {self.database_client.placeholder("access_token")},
+                {self.database_client.placeholder("refresh_token")},
+                {self.database_client.placeholder("expire_at")},
+                {self.database_client.placeholder("refresh_expire_at")},
+                {self.database_client.placeholder("scope")},
+                {self.database_client.placeholder("token_type")},
+                {self.database_client.placeholder("created_at")},
+                {self.database_client.placeholder("updated_at")}
+            )
+            """,
+            args=token.model_dump()
+            | {"created_at": epoch_seconds, "updated_at": epoch_seconds},
+        )
+        return result == 1
+
+    async def update_token(self, token: TokenDataDto):
+        epoch_seconds = int(time.time())
+        result = await self.database_client.execute_cud(
+            query=f"""-- sql
+                    UPDATE authorization_spoon_users
+                    SET access_token = {self.database_client.placeholder("access_token")},
+                    refresh_token =  {self.database_client.placeholder("refresh_token")},
+                    expire_at =  {self.database_client.placeholder("expire_at")},
+                    refresh_expire_at =  {self.database_client.placeholder("expire_at")},
+                    scope = {self.database_client.placeholder("scope")},
+                    token_type = {self.database_client.placeholder("token_type")},
+                    updated_at = {self.database_client.placeholder("updated_at")}
+                    WHERE id = {self.database_client.placeholder("id")}
+                    LIMIT 1
+                    """,  # noqa: E501
+            args=token.model_dump() | {"updated_at": epoch_seconds},
+        )
+        return result == 1
+
+    async def get_token_data(self, id: str) -> TokenDataDto | None:
+        return await self.database_client.execute_one(
+            query=f"""-- sql
+            SELECT 
+                id,
+                access_token,
+                refresh_token,
+                expire_at,
+                refresh_expire_at,
+                scope,
+                token_type,
+                token_status
+            FROM authorization_spoon_users
+            WHERE id = {self.database_client.placeholder("id")}
+            LIMIT 1
+            """,
+            args={"id": id},
+            response_type=TokenDataDto,
+        )
+
+    async def get_token_data_by_session_id(
+        self, encoded_session_id: bytes
+    ) -> TokenDataDto | None:
+        return await self.database_client.execute_one(
+            query=f"""-- sql
+            SELECT 
+                user.id as id,
+                access_token,
+                refresh_token,
+                expire_at,
+                refresh_expire_at,
+                scope,
+                token_type,
+                token_status,
+                csrf_token
+            FROM authorization_spoon_users as user
+            INNER JOIN authorization_spoon_user_sessions as session_tb
+            ON user.id = session_tb.authorization_spoon_user_id
+            WHERE session_tb.encoded_session_id = {self.database_client.placeholder("encoded_session_id")}
+            LIMIT 1
+            """,  # noqa: E501
+            args={"encoded_session_id": encoded_session_id},
+            response_type=TokenDataDto,
+        )
+
+    async def insert_session(self, session_data: SessionDataDto) -> bool:
+        epoch_seconds = int(time.time())
+        result = await self.database_client.execute_cud(
+            query=f"""-- sql
+            INSERT INTO authorization_spoon_user_sessions(
+                id,
+                authorization_spoon_user_id,
+                encoded_session_id,
+                csrf_token,
+                expires_at,
+                created_at,
+                updated_at
+            ) VALUES(
+                {self.database_client.placeholder("id")},
+                {self.database_client.placeholder("authorization_spoon_user_id")},
+                {self.database_client.placeholder("encoded_session_id")},
+                {self.database_client.placeholder("csrf_token")},
+                {self.database_client.placeholder("expires_at")},
+                {self.database_client.placeholder("created_at")},
+                {self.database_client.placeholder("updated_at")}
+            )
+            """,
+            args=session_data.model_dump()
+            | {"created_at": epoch_seconds, "updated_at": epoch_seconds},
+        )
+        return result == 1
+
+    async def get_session_data(
+        self, encoded_session_id: bytes
+    ) -> SessionDataDto | None:
+        return await self.database_client.execute_one(
+            query=f"""-- sql
+            SELECT
+                id,
+                authorization_spoon_user_id,
+                encoded_session_id,
+                csrf_token,
+                expires_at
+            FROM authorization_spoon_user_sessions
+            WHERE encoded_session_id = {self.database_client.placeholder("encoded_session_id")}
+            """,  # noqa: E501
+            args={"encoded_session_id": encoded_session_id},
+            response_type=SessionDataDto,
+        )
+
+    async def update_csrf_token(
+        self, encoded_session_id: bytes, csrf_token: bytes
+    ) -> bool:
+        epoch_seconds = int(time.time())
+        result = await self.database_client.execute_cud(
+            query=f"""-- sql 
+            UPDATE authorization_spoon_user_sessions
+            SET csrf_token = {self.database_client.placeholder("csrf_token")},
+            updated_at = {self.database_client.placeholder("updated_at")}
+            WHERE encoded_session_id = {self.database_client.placeholder("encoded_session_id")}
+            LIMIt 1
+            """,  # noqa: E501
+            args={
+                "encoded_session_id": encoded_session_id,
+                "csrf_token": csrf_token,
+                "updated_at": epoch_seconds,
+            },
+        )
+        return result == 1

spoonbot/db/config/MySQLConfig.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class MySQLConfig:
+    host: str
+    port: int
+    user: str
+    password: str
+    database: str = "spoon_bot"
+    charset: str = "utf8mb4"

spoonbot/db/dto/TokenDataDto.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+
+
+class TokenDataDto(BaseModel):
+    id: str
+    access_token: str
+    token_type: str
+    expire_at: int
+    refresh_token: str
+    refresh_expire_at: int
+    scope: str
+    token_status: str
+
+    encoded_session_id: bytes | None = None
+    csrf_token: bytes | None = None
+
+
+class SessionDataDto(BaseModel):
+    id: bytes
+    authorization_spoon_user_id: str
+    encoded_session_id: bytes
+    csrf_token: bytes | None = None
+    expires_at: int

spoonbot/db/dto/UpdateResult.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class UpdateResult:
+    inserted_count: int | None
+    updated_count: int | None