kabukit 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

kabukit/__init__.py

@@ -1,5 +1,4 @@
-from .cli import app
+from .edinet.client import EdinetClient
+from .jquants.client import JQuantsClient
 
-
-def main() -> None:
-    app()
+__all__ = ["EdinetClient", "JQuantsClient"]

kabukit/cli/app.py

@@ -0,0 +1,22 @@
+"""kabukit CLI."""
+
+from __future__ import annotations
+
+import typer
+from async_typer import AsyncTyper  # pyright: ignore[reportMissingTypeStubs]
+
+from . import auth
+
+app = AsyncTyper(
+    add_completion=False,
+    help="J-Quants/EDINETデータツール",
+)
+app.add_typer(auth.app, name="auth")
+
+
+@app.command()
+def version() -> None:
+    """バージョン情報を表示します。"""
+    from importlib.metadata import version
+
+    typer.echo(f"kabukit version: {version('kabukit')}")

kabukit/cli/auth.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from async_typer import AsyncTyper  # pyright: ignore[reportMissingTypeStubs]
+from httpx import HTTPStatusError
+from typer import Exit, Option
+
+app = AsyncTyper(
+    add_completion=False,
+    help="J-QuantsまたはEDINETの認証トークンを保存します。",
+)
+
+
+async def auth_jquants(mailaddress: str, password: str) -> None:
+    """J-Quants APIの認証を行い、トークンを設定ファイルに保存します。"""
+    from kabukit.jquants.client import JQuantsClient
+
+    async with JQuantsClient() as client:
+        try:
+            await client.auth(mailaddress, password, save=True)
+        except HTTPStatusError as e:
+            typer.echo(f"認証に失敗しました: {e}")
+            raise Exit(1) from None
+
+    typer.echo("J-Quantsのリフレッシュトークン・IDトークンを保存しました。")
+
+
+Mailaddress = Annotated[
+    str,
+    Option(prompt=True, help="J-Quantsに登録したメールアドレス。"),
+]
+Password = Annotated[
+    str,
+    Option(prompt=True, hide_input=True, help="J-Quantsのパスワード。"),
+]
+
+
+@app.async_command()  # pyright: ignore[reportUnknownMemberType]
+async def jquants(mailaddress: Mailaddress, password: Password) -> None:
+    """J-Quants APIの認証を行い、トークンを設定ファイルに保存します。(エイリアス: j)"""
+    await auth_jquants(mailaddress, password)
+
+
+@app.async_command(name="j", hidden=True)  # pyright: ignore[reportUnknownMemberType]
+async def jquants_alias(mailaddress: Mailaddress, password: Password) -> None:
+    await auth_jquants(mailaddress, password)
+
+
+def auth_edinet(api_key: str) -> None:
+    """EDINET APIのAPIキーを設定ファイルに保存します。"""
+    from kabukit.config import set_key
+
+    set_key("EDINET_API_KEY", api_key)
+    typer.echo("EDINETのAPIキーを保存しました。")
+
+
+ApiKey = Annotated[str, Option(prompt=True, help="取得したEDINET APIキー。")]
+
+
+@app.command()
+def edinet(api_key: ApiKey) -> None:
+    """EDINET APIのAPIキーを設定ファイルに保存します。(エイリアス: e)"""
+    auth_edinet(api_key)
+
+
+@app.command(name="e", hidden=True)
+def edinet_alias(api_key: ApiKey) -> None:
+    auth_edinet(api_key)
+
+
+@app.command()
+def show() -> None:
+    """設定ファイルに保存したトークン・APIキーを表示します。"""
+    from dotenv import dotenv_values
+
+    from kabukit.config import get_dotenv_path
+
+    path = get_dotenv_path()
+    typer.echo(f"Configuration file: {path}")
+
+    if path.exists():
+        config = dotenv_values(path)
+        for key, value in config.items():
+            typer.echo(f"{key}: {value}")

kabukit/concurrent.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
+
+MAX_CONCURRENCY = 12
+
+
+async def collect[R](
+    awaitables: Iterable[Awaitable[R]],
+    /,
+    max_concurrency: int | None = None,
+) -> AsyncIterator[R]:
+    max_concurrency = max_concurrency or MAX_CONCURRENCY
+    semaphore = asyncio.Semaphore(max_concurrency)
+
+    async def run(awaitable: Awaitable[R]) -> R:
+        async with semaphore:
+            return await awaitable
+
+    futures = (run(awaitable) for awaitable in awaitables)
+
+    async for future in asyncio.as_completed(futures):
+        yield await future
+
+
+async def collect_fn[T, R](
+    function: Callable[[T], Awaitable[R]],
+    args: Iterable[T],
+    /,
+    max_concurrency: int | None = None,
+) -> AsyncIterator[R]:
+    max_concurrency = max_concurrency or MAX_CONCURRENCY
+    awaitables = (function(arg) for arg in args)
+
+    async for item in collect(awaitables, max_concurrency=max_concurrency):
+        yield item

kabukit/config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from functools import cache
+from pathlib import Path
+
+import dotenv
+from platformdirs import user_config_dir
+
+
+@cache
+def get_dotenv_path() -> Path:
+    """Return the path to the .env file in the user config directory."""
+    config_dir = Path(user_config_dir("kabukit"))
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir / ".env"
+
+
+@cache
+def load_dotenv() -> bool:
+    dotenv_path = get_dotenv_path()
+    return dotenv.load_dotenv(dotenv_path)
+
+
+def set_key(key: str, value: str) -> tuple[bool | None, str, str]:
+    dotenv_path = get_dotenv_path()
+    return dotenv.set_key(dotenv_path, key, value)

kabukit/edinet/client.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import io
+import os
+import zipfile
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+import polars as pl
+from httpx import AsyncClient
+from polars import DataFrame
+
+from kabukit.config import load_dotenv
+from kabukit.params import get_params
+
+if TYPE_CHECKING:
+    import datetime
+
+    from httpx import Response
+    from httpx._types import QueryParamTypes
+
+API_VERSION = "v2"
+BASE_URL = f"https://api.edinet-fsa.go.jp/api/{API_VERSION}"
+
+
+class AuthKey(StrEnum):
+    """Environment variable keys for EDINET authentication."""
+
+    API_KEY = "EDINET_API_KEY"
+
+
+class EdinetClient:
+    client: AsyncClient
+
+    def __init__(self, api_key: str | None = None) -> None:
+        self.client = AsyncClient(base_url=BASE_URL)
+        self.set_api_key(api_key)
+
+    def set_api_key(self, api_key: str | None = None) -> None:
+        if api_key is None:
+            load_dotenv()
+            api_key = os.environ.get(AuthKey.API_KEY)
+
+        if api_key:
+            self.client.params = {"Subscription-Key": api_key}
+
+    async def aclose(self) -> None:
+        await self.client.aclose()
+
+    async def get(self, url: str, params: QueryParamTypes) -> Response:
+        resp = await self.client.get(url, params=params)
+        resp.raise_for_status()
+        return resp
+
+    async def get_count(self, date: str | datetime.date) -> int:
+        params = get_params(date=date, type=1)
+        resp = await self.get("/documents.json", params)
+        data = resp.json()
+        metadata = data["metadata"]
+
+        if metadata["status"] != "200":
+            return 0
+
+        return metadata["resultset"]["count"]
+
+    async def get_list(self, date: str | datetime.date) -> DataFrame:
+        params = get_params(date=date, type=2)
+        resp = await self.get("/documents.json", params)
+        data = resp.json()
+
+        if "results" not in data:
+            return DataFrame()
+
+        return DataFrame(data["results"], infer_schema_length=None)
+
+    async def get_document(self, doc_id: str, doc_type: int) -> Response:
+        params = get_params(type=doc_type)
+        return await self.get(f"/documents/{doc_id}", params)
+
+    async def get_pdf(self, doc_id: str) -> bytes:
+        resp = await self.get_document(doc_id, doc_type=2)
+        if resp.headers["content-type"] == "application/pdf":
+            return resp.content
+
+        msg = "PDF is not available."
+        raise ValueError(msg)
+
+    async def get_zip(self, doc_id: str, doc_type: int) -> bytes:
+        resp = await self.get_document(doc_id, doc_type=doc_type)
+        if resp.headers["content-type"] == "application/octet-stream":
+            return resp.content
+
+        msg = "ZIP is not available."
+        raise ValueError(msg)
+
+    async def get_csv(self, doc_id: str) -> DataFrame:
+        content = await self.get_zip(doc_id, doc_type=5)
+        buffer = io.BytesIO(content)
+
+        with zipfile.ZipFile(buffer) as zf:
+            for info in zf.infolist():
+                if info.filename.endswith(".csv"):
+                    with zf.open(info) as f:
+                        return pl.read_csv(
+                            f.read(),
+                            separator="\t",
+                            encoding="utf-16-le",
+                        )
+
+        msg = "CSV is not available."
+        raise ValueError(msg)

kabukit/jquants/__init__.py

@@ -0,0 +1,3 @@
+from .stream import fetch, fetch_all
+
+__all__ = ["fetch", "fetch_all"]