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

kabukit/jquants/client.py

@@ -6,13 +6,13 @@ 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, set_key
-from kabukit.params import get_params
+from kabukit.core.client import Client
+from kabukit.utils.config import load_dotenv, set_key
+from kabukit.utils.params import get_params
 
-from . import statements
+from . import info, prices, statements
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator
@@ -32,7 +32,7 @@ class AuthKey(StrEnum):
     ID_TOKEN = "JQUANTS_ID_TOKEN"  # noqa: S105
 
 
-class JQuantsClient:
+class JQuantsClient(Client):
     """J-Quants APIと対話するためのクライアント。
 
     API認証トークン（リフレッシュトークンおよびIDトークン）を管理し、
@@ -43,10 +43,8 @@ class JQuantsClient:
         client: APIリクエストを行うための `AsyncClient` インスタンス。
     """
 
-    client: AsyncClient
-
     def __init__(self, id_token: str | None = None) -> None:
-        self.client = AsyncClient(base_url=BASE_URL)
+        super().__init__(BASE_URL)
         self.set_id_token(id_token)
 
     def set_id_token(self, id_token: str | None = None) -> None:
@@ -64,43 +62,6 @@ class JQuantsClient:
         if id_token:
             self.client.headers["Authorization"] = f"Bearer {id_token}"
 
-    async def aclose(self) -> None:
-        """HTTPクライアントを閉じる。"""
-        await self.client.aclose()
-
-    async def __aenter__(self) -> Self:
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:  # pyright: ignore[reportMissingParameterType, reportUnknownParameterType]  # noqa: ANN001
-        await self.aclose()
-
-    async def auth(
-        self,
-        mailaddress: str,
-        password: str,
-        *,
-        save: bool = False,
-    ) -> Self:
-        """認証を行い、トークンを保存する。
-
-        Args:
-            mailaddress (str): J-Quantsに登録したメールアドレス。
-            password (str): J-Quantsのパスワード。
-            save (bool, optional): トークンを環境変数に保存するかどうか。
-
-        Raises:
-            HTTPStatusError: APIリクエストが失敗した場合。
-        """
-        refresh_token = await self.get_refresh_token(mailaddress, password)
-        id_token = await self.get_id_token(refresh_token)
-
-        if save:
-            set_key(AuthKey.REFRESH_TOKEN, refresh_token)
-            set_key(AuthKey.ID_TOKEN, id_token)
-
-        self.set_id_token(id_token)
-        return self
-
     async def post(self, url: str, json: Any | None = None) -> Any:
         """指定されたURLにPOSTリクエストを送信する。
 
@@ -118,55 +79,54 @@ class JQuantsClient:
         resp.raise_for_status()
         return resp.json()
 
-    async def get_refresh_token(self, mailaddress: str, password: str) -> str:
-        """APIから新しいリフレッシュトークンを取得する。
+    async def get(self, url: str, params: QueryParamTypes | None = None) -> Any:
+        """指定されたURLにGETリクエストを送信する。
 
         Args:
-            mailaddress (str): ユーザーのメールアドレス。
-            password (str): ユーザーのパスワード。
+            url (str): GETリクエストのURLパス。
+            params (QueryParamTypes | None, optional): リクエストのクエリパラメータ。
 
         Returns:
-            新しいリフレッシュトークン。
+            APIからのJSONレスポンス。
 
         Raises:
             HTTPStatusError: APIリクエストが失敗した場合。
         """
-        json_data = {"mailaddress": mailaddress, "password": password}
-        data = await self.post("/token/auth_user", json=json_data)
-        return data["refreshToken"]
+        resp = await self.client.get(url, params=params)
+        resp.raise_for_status()
+        return resp.json()
 
-    async def get_id_token(self, refresh_token: str) -> str:
-        """APIから新しいIDトークンを取得する。
+    async def auth(
+        self,
+        mailaddress: str,
+        password: str,
+        *,
+        save: bool = False,
+    ) -> Self:
+        """認証を行い、トークンを保存する。
 
         Args:
-            refresh_token (str): 使用するリフレッシュトークン。
-
-        Returns:
-            新しいIDトークン。
+            mailaddress (str): J-Quantsに登録したメールアドレス。
+            password (str): J-Quantsのパスワード。
+            save (bool, optional): トークンを環境変数に保存するかどうか。
 
         Raises:
             HTTPStatusError: APIリクエストが失敗した場合。
         """
+        json_data = {"mailaddress": mailaddress, "password": password}
+        data = await self.post("/token/auth_user", json=json_data)
+        refresh_token = data["refreshToken"]
+
         url = f"/token/auth_refresh?refreshtoken={refresh_token}"
         data = await self.post(url)
-        return data["idToken"]
-
-    async def get(self, url: str, params: QueryParamTypes | None = None) -> Any:
-        """指定されたURLにGETリクエストを送信する。
-
-        Args:
-            url (str): GETリクエストのURLパス。
-            params (QueryParamTypes | None, optional): リクエストのクエリパラメータ。
+        id_token = data["idToken"]
 
-        Returns:
-            APIからのJSONレスポンス。
+        if save:
+            set_key(AuthKey.REFRESH_TOKEN, refresh_token)
+            set_key(AuthKey.ID_TOKEN, id_token)
 
-        Raises:
-            HTTPStatusError: APIリクエストが失敗した場合。
-        """
-        resp = await self.client.get(url, params=params)
-        resp.raise_for_status()
-        return resp.json()
+        self.set_id_token(id_token)
+        return self
 
     async def get_info(
         self,
@@ -176,8 +136,8 @@ class JQuantsClient:
         """銘柄情報を取得する。
 
         Args:
-            code (str | None, optional): 情報を取得する銘柄のコード。
-            date (str | datetime.date | None, optional): 情報を取得する日付。
+            code (str, optional): 情報を取得する銘柄のコード。
+            date (str | datetime.date, optional): 情報を取得する日付。
 
         Returns:
             銘柄情報を含むPolars DataFrame。
@@ -188,12 +148,7 @@ class JQuantsClient:
         params = get_params(code=code, date=date)
         url = "/listed/info"
         data = await self.get(url, params)
-        df = DataFrame(data["info"])
-
-        return df.with_columns(
-            pl.col("Date").str.to_date("%Y-%m-%d"),
-            pl.col("^.*CodeName$", "ScaleCategory").cast(pl.Categorical),
-        ).drop("^.+Code$", "CompanyNameEnglish")
+        return DataFrame(data["info"]).pipe(info.clean)
 
     async def iter_pages(
         self,
@@ -233,11 +188,16 @@ class JQuantsClient:
     ) -> DataFrame:
         """日々の株価四本値を取得する。
 
+        株価は分割・併合を考慮した調整済み株価（小数点第２位四捨五入）と調整前の株価を取得できる。
+
         Args:
-            code: 株価を取得する銘柄のコード。
-            date: 株価を取得する特定の日付。`from_`または`to`とは併用不可。
-            from_: 取得期間の開始日。`date`とは併用不可。
-            to: 取得期間の終了日。`date`とは併用不可。
+            code (str, optional): 株価を取得する銘柄のコード。
+            date (str | datetime.date, optional): 株価を取得する日付。
+                `from_`または`to`とは併用不可。
+            from_ (str | datetime.date, optional): 取得期間の開始日。
+                `date`とは併用不可。
+            to (str | datetime.date, optional): 取得期間の終了日。
+                `date`とは併用不可。
 
         Returns:
             日々の株価四本値を含むPolars DataFrame。
@@ -250,7 +210,7 @@ class JQuantsClient:
             return await self.get_latest_available_prices()
 
         if date and (from_ or to):
-            msg = "Cannot specify both date and from/to parameters."
+            msg = "dateとfrom/toの両方を指定することはできません。"
             raise ValueError(msg)
 
         params = get_params(code=code, date=date, from_=from_, to=to)
@@ -264,16 +224,13 @@ class JQuantsClient:
         if df.is_empty():
             return df
 
-        return df.with_columns(
-            pl.col("Date").str.to_date("%Y-%m-%d"),
-            pl.col("^.*Limit$").cast(pl.Int8).cast(pl.Boolean),
-        )
+        return prices.clean(df)
 
-    async def get_latest_available_prices(self) -> DataFrame:
+    async def get_latest_available_prices(self, num_days: int = 30) -> DataFrame:
         """直近利用可能な日付の株価を取得する。"""
         today = datetime.date.today()  # noqa: DTZ011
 
-        for days in range(30):
+        for days in range(num_days):
             date = today - datetime.timedelta(days)
             df = await self.get_prices(date=date)
 
@@ -287,18 +244,23 @@ class JQuantsClient:
         code: str | None = None,
         date: str | datetime.date | None = None,
     ) -> DataFrame:
-        """財務情報を取得する。
+        """四半期毎の決算短信サマリーおよび業績・配当の修正に関する開示情報を取得する。
 
         Args:
-            code: 財務情報を取得する銘柄のコード。
-            date: 財務情報を取得する日付。
+            code (str, optional): 財務情報を取得する銘柄のコード。
+            date (str | datetime.date, optional): 財務情報を取得する日付。
 
         Returns:
-            財務情報を含むPolars DataFrame。
+            財務情報を含むDataFrame。
 
         Raises:
+            ValueError: `code`と`date`が両方とも指定されない場合。
             HTTPStatusError: APIリクエストが失敗した場合。
         """
+        if not code and not date:
+            msg = "codeまたはdateのどちらかを指定する必要があります。"
+            raise ValueError(msg)
+
         params = get_params(code=code, date=date)
         url = "/fins/statements"
         name = "statements"

kabukit/jquants/{stream.py → concurrent.py}

@@ -1,47 +1,18 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Protocol
+from typing import TYPE_CHECKING
 
-import polars as pl
-
-from kabukit.concurrent import collect_fn
+from kabukit.utils import concurrent
 
 from .client import JQuantsClient
 from .info import get_codes
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterable, AsyncIterator, Callable, Iterable
+    from collections.abc import Iterable
 
     from polars import DataFrame
 
-    class Progress(Protocol):
-        def __call__[T](
-            self,
-            aiterable: AsyncIterable[T],
-            total: int | None = None,
-            *args: Any,
-            **kwargs: Any,
-        ) -> AsyncIterator[T]: ...
-
-
-type Callback = Callable[[DataFrame], DataFrame | None]
-
-
-@dataclass
-class Stream:
-    """JQuantsから各種データを銘柄コードごとにストリーム形式で取得する。"""
-
-    resource: str
-    codes: list[str]
-    max_concurrency: int | None = None
-
-    async def __aiter__(self) -> AsyncIterator[DataFrame]:
-        async with JQuantsClient() as client:
-            fn = getattr(client, f"get_{self.resource}")
-
-            async for df in collect_fn(fn, self.codes, self.max_concurrency):
-                yield df
+    from kabukit.utils.concurrent import Callback, Progress
 
 
 async def fetch(
@@ -70,16 +41,14 @@ async def fetch(
         DataFrame:
             すべての銘柄の財務情報を含む単一のDataFrame。
     """
-    codes = list(codes)
-    stream = Stream(resource, codes, max_concurrency)
-
-    if progress:
-        stream = progress(aiter(stream), total=len(codes))
-
-    if callback:
-        stream = (x if (r := callback(x)) is None else r async for x in stream)
-
-    return pl.concat([df async for df in stream if not df.is_empty()])
+    return await concurrent.fetch(
+        JQuantsClient,
+        resource,
+        codes,
+        max_concurrency=max_concurrency,
+        progress=progress,
+        callback=callback,
+    )
 
 
 async def fetch_all(

kabukit/jquants/info.py

@@ -1,8 +1,14 @@
 from __future__ import annotations
 
 import polars as pl
+from polars import DataFrame
 
-from .client import JQuantsClient
+
+def clean(df: DataFrame) -> DataFrame:
+    return df.with_columns(
+        pl.col("Date").str.to_date("%Y-%m-%d"),
+        pl.col("^.*CodeName$", "ScaleCategory").cast(pl.Categorical),
+    ).drop("^.+Code$", "CompanyNameEnglish")
 
 
 async def get_codes() -> list[str]:
@@ -10,6 +16,8 @@ async def get_codes() -> list[str]:
 
     市場「TOKYO PRO MARKET」と業種「その他」を除外した銘柄を対象とする。
     """
+    from .client import JQuantsClient
+
     async with JQuantsClient() as client:
         info = await client.get_info()
 

kabukit/jquants/prices.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import polars as pl
+
+if TYPE_CHECKING:
+    from polars import DataFrame
+
+
+def clean(df: DataFrame) -> DataFrame:
+    return df.select(
+        pl.col("Date").str.to_date("%Y-%m-%d"),
+        "Code",
+        Open=pl.col("AdjustmentOpen"),
+        High=pl.col("AdjustmentHigh"),
+        Low=pl.col("AdjustmentLow"),
+        Close=pl.col("AdjustmentClose"),
+        UpperLimit=pl.col("UpperLimit").cast(pl.Int8).cast(pl.Boolean),
+        LowerLimit=pl.col("LowerLimit").cast(pl.Int8).cast(pl.Boolean),
+        Volume=pl.col("AdjustmentVolume"),
+        TurnoverValue=pl.col("TurnoverValue"),
+        AdjustmentFactor=pl.col("AdjustmentFactor"),
+        RawOpen=pl.col("Open"),
+        RawHigh=pl.col("High"),
+        RawLow=pl.col("Low"),
+        RawClose=pl.col("Close"),
+        RawVolume=pl.col("Volume"),
+    )

kabukit/jquants/schema.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 
 class BaseColumns(Enum):
     @classmethod
-    def rename(cls, df: DataFrame, *, strict: bool = True) -> DataFrame:
+    def rename(cls, df: DataFrame, *, strict: bool = False) -> DataFrame:
         """DataFrameの列名を日本語から英語に変換する。"""
         return df.rename({x.name: x.value for x in cls}, strict=strict)
 
@@ -37,11 +37,11 @@ class PriceColumns(BaseColumns):
     Volume = "出来高"
     TurnoverValue = "売買代金"
     AdjustmentFactor = "調整係数"
-    AdjustmentOpen = "調整済始値"
-    AdjustmentHigh = "調整済高値"
-    AdjustmentLow = "調整済安値"
-    AdjustmentClose = "調整済終値"
-    AdjustmentVolume = "調整済取引高"
+    RawOpen = "調整前始値"
+    RawHigh = "調整前高値"
+    RawLow = "調整前安値"
+    RawClose = "調整前終値"
+    RawVolume = "調整前出来高"
 
 
 class StatementColumns(BaseColumns):
@@ -129,10 +129,13 @@ class StatementColumns(BaseColumns):
     ChangesInAccountingEstimates = "会計上の見積りの変更"
     RetrospectiveRestatement = "修正再表示"
 
-    NumberOfIssuedAndOutstandingSharesAtTheEndOfFiscalYearIncludingTreasuryStock = "期末発行済株式数"
-    NumberOfTreasuryStockAtTheEndOfFiscalYear = "期末自己株式数"
+    # NumberOfIssuedAndOutstandingSharesAtTheEndOfFiscalYearIncludingTreasuryStock
+    NumberOfShares = "期末発行済株式数"
+    # NumberOfTreasuryStockAtTheEndOfFiscalYear
+    NumberOfTreasuryStock = "期末自己株式数"
     AverageNumberOfShares = "期中平均株式数"
 
+    """
     NonConsolidatedNetSales = "売上高_非連結"
     NonConsolidatedOperatingProfit = "営業利益_非連結"
     NonConsolidatedOrdinaryProfit = "経常利益_非連結"
@@ -167,3 +170,11 @@ class StatementColumns(BaseColumns):
     NextYearForecastNonConsolidatedOrdinaryProfit = "経常利益_予想_翌事業年度期末_非連結"
     NextYearForecastNonConsolidatedProfit = "当期純利益_予想_翌事業年度期末_非連結"
     NextYearForecastNonConsolidatedEarningsPerShare = "一株あたり当期純利益_予想_翌事業年度期末_非連結"
+    """
+
+
+def rename(df: DataFrame, *, strict: bool = False) -> DataFrame:
+    """DataFrameの列名を日本語から英語に変換する。"""
+    for enum in (InfoColumns, PriceColumns, StatementColumns):
+        df = enum.rename(df, strict=strict)
+    return df

kabukit/jquants/statements.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import datetime
+from functools import cache
 from typing import TYPE_CHECKING, Any, Protocol
 
+import holidays
 import polars as pl
 
 if TYPE_CHECKING:
@@ -21,9 +24,15 @@ if TYPE_CHECKING:
 
 def clean(df: DataFrame) -> DataFrame:
     return (
-        df.select(pl.exclude(r"^.*\(REIT\)$"))
+        df.select(pl.exclude(r"^.*\(REIT\)|.*NonConsolidated.*$"))
         .rename(
-            {"DisclosedDate": "Date", "DisclosedTime": "Time", "LocalCode": "Code"},
+            {
+                "DisclosedDate": "Date",
+                "DisclosedTime": "Time",
+                "LocalCode": "Code",
+                "NumberOfIssuedAndOutstandingSharesAtTheEndOfFiscalYearIncludingTreasuryStock": "NumberOfShares",  # noqa: E501
+                "NumberOfTreasuryStockAtTheEndOfFiscalYear": "NumberOfTreasuryStock",
+            },
         )
         .with_columns(
             pl.col("^.*Date$").str.to_date("%Y-%m-%d", strict=False),
@@ -67,3 +76,27 @@ def _cast_bool(df: DataFrame) -> DataFrame:
         .alias(col)
         for col in columns
     )
+
+
+@cache
+def get_holidays(year: int | None = None, n: int = 10) -> list[datetime.date]:
+    """指定した過去年数の日本の祝日を取得する。"""
+    if year is None:
+        year = datetime.datetime.now().year  # noqa: DTZ005
+
+    dates = holidays.country_holidays("JP", years=range(year - n, year + 1))
+    return sorted(dates.keys())
+
+
+def update_effective_date(df: DataFrame, year: int | None = None) -> DataFrame:
+    """開示日が休日や15時以降の場合、翌営業日に更新する。"""
+    holidays = get_holidays(year=year)
+
+    cond = pl.col("Time").is_null() | (pl.col("Time") > datetime.time(15, 0))
+
+    return df.with_columns(
+        pl.when(cond)
+        .then(pl.col("Date").dt.add_business_days(1, holidays=holidays))
+        .otherwise(pl.col("Date"))
+        .alias("Date"),
+    )

kabukit/utils/concurrent.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Protocol
+
+import polars as pl
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        AsyncIterable,
+        AsyncIterator,
+        Awaitable,
+        Callable,
+        Iterable,
+    )
+    from typing import Any
+
+    from marimo._plugins.stateless.status import progress_bar
+    from polars import DataFrame
+    from tqdm.asyncio import tqdm
+
+    from kabukit.core.client import Client
+
+    class _Progress(Protocol):
+        def __call__[T](
+            self,
+            aiterable: AsyncIterable[T],
+            total: int | None = None,
+            *args: Any,
+            **kwargs: Any,
+        ) -> AsyncIterator[T]: ...
+
+
+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
+
+
+async def concat(
+    awaitables: Iterable[Awaitable[DataFrame]],
+    /,
+    max_concurrency: int | None = None,
+) -> DataFrame:
+    dfs = collect(awaitables, max_concurrency=max_concurrency)
+    dfs = [df async for df in dfs]
+    return pl.concat(df for df in dfs if not df.is_empty())
+
+
+async def concat_fn[T](
+    function: Callable[[T], Awaitable[DataFrame]],
+    args: Iterable[T],
+    /,
+    max_concurrency: int | None = None,
+) -> DataFrame:
+    dfs = collect_fn(function, args, max_concurrency=max_concurrency)
+    dfs = [df async for df in dfs]
+    return pl.concat(df for df in dfs if not df.is_empty())
+
+
+type Callback = Callable[[DataFrame], DataFrame | None]
+type Progress = type[progress_bar[Any] | tqdm[Any]] | _Progress
+
+
+@dataclass
+class Stream:
+    cls: type[Client]
+    resource: str
+    args: list[Any]
+    max_concurrency: int | None = None
+
+    async def __aiter__(self) -> AsyncIterator[DataFrame]:
+        async with self.cls() as client:
+            fn = getattr(client, f"get_{self.resource}")
+
+            async for df in collect_fn(fn, self.args, self.max_concurrency):
+                yield df
+
+
+async def fetch(
+    cls: type[Client],
+    resource: str,
+    args: Iterable[Any],
+    /,
+    max_concurrency: int | None = None,
+    progress: Progress | None = None,
+    callback: Callback | None = None,
+) -> DataFrame:
+    """各種データを取得し、単一のDataFrameにまとめて返す。
+
+    Args:
+        cls (type[Client]): 使用するClientクラス。
+            JQuantsClientやEdinetClientなど、Clientを継承したクラス
+        resource (str): 取得するデータの種類。Clientのメソッド名から"get_"を
+            除いたものを指定する。
+        args (Iterable[Any]): 取得対象の引数のリスト。
+        max_concurrency (int | None, optional): 同時に実行するリクエストの最大数。
+            指定しないときはデフォルト値が使用される。
+        progress (Progress | None, optional): 進捗表示のための関数。
+            tqdm, marimoなどのライブラリを使用できる。
+            指定しないときは進捗表示は行われない。
+        callback (Callback | None, optional): 各DataFrameに対して適用する
+            コールバック関数。指定しないときはそのままのDataFrameが使用される。
+
+    Returns:
+        DataFrame:
+            すべての情報を含む単一のDataFrame。
+    """
+    args = list(args)
+    stream = Stream(cls, resource, args, max_concurrency)
+
+    if progress:
+        stream = progress(aiter(stream), total=len(args))
+
+    if callback:
+        stream = (x if (r := callback(x)) is None else r async for x in stream)
+
+    dfs = [df async for df in stream if not df.is_empty()]
+    return pl.concat(dfs) if dfs else pl.DataFrame()