kabuchart-cli 0.1.0__py3-none-any.whl

kabuchart/__init__.py

@@ -0,0 +1,3 @@
+"""Terminal-based stock chart CLI for Japanese stocks."""
+
+__version__ = "0.1.0"

kabuchart/_internal/chart.py

@@ -0,0 +1,351 @@
+"""Terminal chart rendering."""
+
+from __future__ import annotations
+
+import math
+
+from kabuchart._internal.models import StockData
+
+
+def _format_market_cap(value: float | None) -> str:
+    """Format market cap like kabutan: 54兆6,822億円 for ≥10000億, else 9,999億円."""
+    if value is None:
+        return "-"
+    if value >= 10000:
+        cho = int(value) // 10000
+        oku = int(value) % 10000
+        return f"{cho}兆{oku:,}億円"
+    return f"{value:,.0f}億円"
+
+
+def _source_line(data: StockData) -> str:
+    """Build source log line: [kabutan] etc."""
+    return f"[{data.source}]"
+
+
+def _display_width(s: str) -> int:
+    """Calculate display width accounting for East Asian wide characters."""
+    import unicodedata
+
+    w = 0
+    for ch in s:
+        eaw = unicodedata.east_asian_width(ch)
+        w += 2 if eaw in ("F", "W") else 1
+    return w
+
+
+def _pad_to_width(s: str, width: int) -> str:
+    """Pad string with spaces to reach target display width."""
+    current = _display_width(s)
+    if current >= width:
+        return s
+    return s + " " * (width - current)
+
+
+def _wrap_text(text: str, width: int) -> list[str]:
+    """Wrap text to fit within display width, respecting East Asian characters."""
+    lines: list[str] = []
+    current = ""
+    current_w = 0
+    for ch in text:
+        ch_w = 2 if _display_width(ch) == 2 else 1
+        if current_w + ch_w > width:
+            lines.append(current)
+            current = ch
+            current_w = ch_w
+        else:
+            current += ch
+            current_w += ch_w
+    if current:
+        lines.append(current)
+    return lines
+
+
+def _header(data: StockData, min_box_width: int = 80, *, verbose: bool = False) -> str:
+    """Build kabutan-style two-panel header info box.
+
+    Left panel: stock info + price (2 rows).
+    Right panel: metric columns with header/value rows.
+    Bottom row: market cap spanning full width.
+
+    ┌──────────────────────────────────────┬──────────┬───────┬───────┬──────┬────────┐
+    │ 7203  トヨタ自動車  東証Ｐ     13:43 │ 業種     │ PER   │ PBR   │利回り│信用倍率│
+    │ 3,462.0円  前日比  +69.0 (+2.03%)    │ 輸送用機器│12.6倍 │1.16倍 │2.74% │2.07倍 │
+    ├──────────────────────────────────────┴──────────┴───────┴───────┴──────┴────────┤
+    │ 時価総額  547,138億円                                                           │
+    └────────────────────────────────────────────────────────────────────────────────┘
+    """
+    i = data.info
+
+    # Right-side metric columns: (header, value) pairs
+    right_cols: list[tuple[str, str]] = []
+    if i.industry:
+        right_cols.append(("業種", i.industry))
+    if i.per is not None:
+        right_cols.append(("PER", f"{i.per:.1f}倍"))
+    if i.pbr is not None:
+        right_cols.append(("PBR", f"{i.pbr:.2f}倍"))
+    if i.dividend_yield is not None:
+        right_cols.append(("利回り", f"{i.dividend_yield:.2f}%"))
+    if i.margin_ratio is not None:
+        right_cols.append(("信用倍率", f"{i.margin_ratio:.2f}倍"))
+    if i.market_cap is not None:
+        right_cols.append(("時価総額", _format_market_cap(i.market_cap)))
+
+    if not right_cols:
+        return _header_simple(data, min_box_width)
+
+    # Column widths: max(header, value) display width + 2 padding
+    col_widths = [
+        max(_display_width(h), _display_width(v)) + 2
+        for h, v in right_cols
+    ]
+    n = len(right_cols)
+    right_total = sum(col_widths) + n  # n separators
+
+    # Left panel content
+    left_parts = [f"{data.ticker}  {data.name}"]
+    if i.market:
+        left_parts.append(i.market)
+    left1_text = "    ".join(left_parts)
+    time_str = data.live.time if data.live and data.live.time else ""
+    line2_text = _price_line(data)
+
+    # Compute minimum left panel width from content
+    if time_str:
+        left_min = _display_width(left1_text) + 4 + len(time_str)  # " text  time"
+    else:
+        left_min = _display_width(left1_text) + 2  # " text "
+    left_min = max(left_min, _display_width(line2_text) + 2)  # " price_line "
+
+    # Determine box width: fit content or min_box_width, whichever is larger
+    inner = max(left_min + right_total, min_box_width - 2)
+    left_width = inner - right_total
+
+    # Build left panel content
+    if time_str:
+        gap = left_width - _display_width(left1_text) - len(time_str) - 1
+        line1_left = " " + left1_text + " " * max(gap, 2) + time_str
+    else:
+        line1_left = " " + left1_text
+    line2_left = " " + line2_text
+
+    # Build right-side cells
+    hdr_cells = []
+    val_cells = []
+    for (h, v), w in zip(right_cols, col_widths):
+        hdr_cells.append(" " + _pad_to_width(h, w - 1))
+        val_cells.append(" " + _pad_to_width(v, w - 1))
+
+    # Assemble rows
+    row1 = ("│" + _pad_to_width(line1_left, left_width)
+            + "│" + "│".join(hdr_cells) + "│")
+    row2 = ("│" + _pad_to_width(line2_left, left_width)
+            + "│" + "│".join(val_cells) + "│")
+
+    # Borders
+    top = ("┌" + "─" * left_width
+           + "┬" + "┬".join("─" * w for w in col_widths) + "┐")
+
+    lines = [top, row1, row2]
+
+    # Bottom section: description only (verbose mode)
+    if verbose and i.description:
+        mid = ("├" + "─" * left_width
+               + "┴" + "┴".join("─" * w for w in col_widths) + "┤")
+        lines.append(mid)
+
+        desc_width = inner - 2  # 1 space padding each side
+        for dline in _wrap_text(i.description, desc_width):
+            lines.append("│ " + _pad_to_width(dline, inner - 1) + "│")
+
+        bot = "└" + "─" * inner + "┘"
+        lines.append(bot)
+    else:
+        bot = ("└" + "─" * left_width
+               + "┴" + "┴".join("─" * w for w in col_widths) + "┘")
+        lines.append(bot)
+
+    return "\n".join(lines)
+
+
+def _header_simple(data: StockData, box_width: int = 80) -> str:
+    """Fallback simple header when no metric columns available."""
+    inner = box_width - 2
+    left_parts = [f"{data.ticker}  {data.name}"]
+    if data.info.market:
+        left_parts.append(data.info.market)
+    if data.info.industry:
+        left_parts.append(data.info.industry)
+    line1 = "    ".join(left_parts)
+    time_str = data.live.time if data.live and data.live.time else ""
+    if time_str:
+        gap = inner - _display_width(line1) - len(time_str)
+        line1 = line1 + " " * max(gap, 2) + time_str
+
+    line2 = _price_line(data)
+
+    top = "┌" + "─" * inner + "┐"
+    row1 = "│ " + _pad_to_width(line1, inner - 1) + "│"
+    row2 = "│ " + _pad_to_width(line2, inner - 1) + "│"
+    bot = "└" + "─" * inner + "┘"
+    return "\n".join([top, row1, row2, bot])
+
+
+def _price_line(data: StockData) -> str:
+    """Build price line using live price if available, else OHLCV close."""
+    if data.live:
+        lp = data.live
+        sign = "+" if lp.change >= 0 else ""
+        return f"{lp.price:,.1f}円    前日比  {sign}{lp.change:,.1f} ({sign}{lp.change_pct:.2f}%)"
+
+    # Fallback: use latest OHLCV close
+    if not data.records:
+        return ""
+    if len(data.records) < 2:
+        return f"{data.records[-1].close:,.1f}円"
+    latest = data.records[-1]
+    prev = data.records[-2]
+    diff = latest.close - prev.close
+    pct = (diff / prev.close) * 100
+    sign = "+" if diff >= 0 else ""
+    return f"{latest.close:,.1f}円    前日比  {sign}{diff:,.1f} ({sign}{pct:.2f}%)"
+
+
+def _date_axis(data: StockData, chart_width: int, n_visible: int) -> str:
+    """Build date axis labels like kabutan: 26/1, 2, 3."""
+    if not data.records:
+        return ""
+
+    dates = data.dates[-n_visible:]
+    n = len(dates)
+    if n == 0:
+        return ""
+
+    y_axis_width = chart_width - n
+    if y_axis_width < 0:
+        y_axis_width = 0
+
+    labels: list[tuple[int, str]] = []
+    prev_month = None
+    for i, d in enumerate(dates):
+        ym = (d.year, d.month)
+        if ym != prev_month:
+            if prev_month is None or d.year != prev_month[0]:
+                label = f"{d.year % 100}/{d.month}"
+            else:
+                label = str(d.month)
+            labels.append((i, label))
+            prev_month = ym
+
+    axis = [" "] * n
+    for pos, label in labels:
+        for j, ch in enumerate(label):
+            idx = pos + j
+            if idx < n:
+                axis[idx] = ch
+
+    return " " * y_axis_width + "".join(axis)
+
+
+def _nice_step(price_range: float, target_ticks: int = 5) -> float:
+    """Compute a nice round step size for y-axis ticks.
+
+    Picks the largest "nice" number (1, 2, 5, 10 × magnitude) that yields
+    at least *target_ticks* ticks across the price range.
+    """
+    if price_range <= 0:
+        return 1.0
+    raw = price_range / target_ticks
+    magnitude = 10 ** math.floor(math.log10(raw))
+    # Pick the largest nice step that is <= raw (so we get enough ticks).
+    for nice in (10, 5, 2, 1):
+        candidate = nice * magnitude
+        if candidate <= raw:
+            return candidate
+    return magnitude
+
+
+def _configure_y_axis(data: StockData, chart_height: int) -> None:
+    """Set candlestick-chart y-axis constants for nice round tick labels."""
+    from candlestick_chart import constants as cc
+
+    prices = data.highs + data.lows
+    if not prices:
+        return
+    price_range = max(prices) - min(prices)
+
+    # Target enough ticks so labels appear every ~5 rows.
+    target_ticks = max(chart_height // 5, 4)
+    step = _nice_step(price_range, target_ticks)
+
+    cc.Y_AXIS_ROUND_MULTIPLIER = 1.0 / step
+    cc.Y_AXIS_ROUND_DIR = "down"
+    # Show integer ticks for prices >= 100
+    if step >= 1:
+        cc.PRECISION = 0
+    else:
+        cc.PRECISION = 2
+
+    # Set Y_AXIS_SPACING so each tick shows a distinct value.
+    if price_range > 0:
+        num_ticks = max(price_range / step, 1)
+        cc.Y_AXIS_SPACING = max(3, math.ceil(chart_height / num_ticks))
+    else:
+        cc.Y_AXIS_SPACING = 4
+
+
+def render(data: StockData, *, quiet: bool = False, verbose: bool = False) -> None:
+    """Render stock data as a terminal candlestick chart."""
+    from shutil import get_terminal_size
+
+    from candlestick_chart import Candle, Chart
+
+    # Source log (can be suppressed with --quiet)
+    if not quiet:
+        print(_source_line(data))
+
+    # Kabutan-style header
+    print(_header(data, verbose=verbose))
+
+    # Compact chart height: fit header + chart + date axis in one screen.
+    # Reserve rows for: header box (~6) + source line (1) + date axis (1) + margin (2).
+    term_w, term_h = get_terminal_size()
+    chart_total_h = min(term_h - 10, 32)  # total chart widget height
+    chart_total_h = max(chart_total_h, 20)  # floor at 20
+
+    candles = [
+        Candle(
+            open=r.open,
+            close=r.close,
+            high=r.high,
+            low=r.low,
+            volume=r.volume,
+        )
+        for r in data.records
+    ]
+
+    chart = Chart(candles, title="", height=chart_total_h)
+    chart.set_volume_pane_enabled(True)
+
+    # Configure y-axis using actual chart height after library computes it
+    _configure_y_axis(data, chart.chart_data.height)
+
+    # Get rendered chart, strip bottom info bar
+    rendered = chart._render()  # noqa: SLF001
+    lines = rendered.split("\n")
+
+    while lines and not lines[-1].strip():
+        lines.pop()
+    if lines and not lines[-1].startswith("─"):
+        lines.pop()
+    while lines and not lines[-1].strip():
+        lines.pop()
+
+    # Date axis
+    n_visible = len(chart.chart_data.visible_candle_set.candles)
+    date_line = _date_axis(data, chart.chart_data.width, n_visible)
+    if date_line:
+        lines.append(date_line)
+
+    print("\n".join(lines))

kabuchart/_internal/config.py

@@ -0,0 +1,49 @@
+"""Configuration loading with layered precedence."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+CONFIG_DIR = Path.home() / ".config" / "kabuchart"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+@dataclass
+class Config:
+    """Application configuration."""
+
+    jquants_api_key: str | None = None
+    data_source_priority: list[str] = field(
+        default_factory=lambda: ["pyjquants", "pykabutan", "yfinance"]
+    )
+
+    @classmethod
+    def load(cls) -> Config:
+        """Load config: env vars override config.toml."""
+        file_config = _load_toml()
+        return cls(
+            jquants_api_key=(
+                os.environ.get("JQUANTS_API_KEY")
+                or file_config.get("jquants_api_key")
+            ),
+            data_source_priority=file_config.get(
+                "data_source_priority",
+                ["pyjquants", "pykabutan", "yfinance"],
+            ),
+        )
+
+
+def _load_toml() -> dict:
+    """Load config from TOML file. Returns empty dict if not found."""
+    if not CONFIG_FILE.exists():
+        return {}
+    with open(CONFIG_FILE, "rb") as f:
+        return tomllib.load(f)

kabuchart/_internal/data.py

@@ -0,0 +1,194 @@
+"""Cascading data fetch: pyjquants → yfinance → pykabutan."""
+
+from __future__ import annotations
+
+import re
+
+from kabuchart._internal.config import Config
+from kabuchart._internal.models import OHLCV, LivePrice, StockData, StockInfo
+
+
+def fetch(ticker: str, period: str, config: Config | None = None) -> StockData:
+    """Fetch OHLCV data using cascading data sources."""
+    if config is None:
+        config = Config.load()
+
+    errors: list[str] = []
+    for source in config.data_source_priority:
+        fetcher = _FETCHERS.get(source)
+        if fetcher is None:
+            continue
+        try:
+            return fetcher(ticker, period, config)
+        except Exception as e:  # noqa: BLE001
+            errors.append(f"{source}: {e}")
+
+    raise RuntimeError(
+        f"All data sources failed for {ticker}:\n" + "\n".join(errors)
+    )
+
+
+def _parse_live_price(soup) -> LivePrice | None:
+    """Extract live/delayed price from kabutan main page soup."""
+    try:
+        # Scope to the stock info container to avoid matching index data
+        container = soup.select_one("div#stockinfo_i1")
+        if not container:
+            return None
+
+        kabuka = container.select_one("span.kabuka")
+        if not kabuka:
+            return None
+        price_text = kabuka.get_text(strip=True).replace(",", "").replace("円", "")
+        price = float(price_text)
+
+        # Change: look for span.up or span.down within the container
+        change_el = container.select_one("span.up") or container.select_one("span.down")
+        change = 0.0
+        if change_el:
+            change_text = change_el.get_text(strip=True).replace(",", "")
+            change = float(change_text)
+
+        # Percent change
+        change_pct = (change / (price - change)) * 100 if price != change else 0.0
+
+        # Time from si_i1_1_rbox
+        time_str = ""
+        time_el = container.select_one("div.si_i1_1_rbox")
+        if time_el:
+            text = time_el.get_text(strip=True)
+            m = re.search(r"(\d{1,2}:\d{2})", text)
+            if m:
+                time_str = m.group(1)
+
+        return LivePrice(price=price, change=change, change_pct=change_pct, time=time_str)
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _get_kabutan_profile(ticker: str):
+    """Get pykabutan Ticker and profile. Returns (name, StockInfo, LivePrice|None) or ("", StockInfo(), None)."""
+    try:
+        import pykabutan as pk
+
+        t = pk.Ticker(ticker)
+        p = t.profile
+        info = StockInfo(
+            market=p.market or "",
+            industry=p.industry or "",
+            per=p.per,
+            pbr=p.pbr,
+            dividend_yield=p.dividend_yield,
+            market_cap=p.market_cap,
+            margin_ratio=p.margin_ratio,
+            description=p.description or "",
+        )
+        live = _parse_live_price(t._soup)  # noqa: SLF001
+        return p.name, info, live
+    except Exception:  # noqa: BLE001
+        return "", StockInfo(), None
+
+
+def _fetch_yfinance(ticker: str, period: str, _config: Config) -> StockData:
+    import yfinance as yf
+
+    yf_ticker = f"{ticker}.T"
+    df = yf.Ticker(yf_ticker).history(period=period)
+    if df.empty:
+        raise ValueError(f"No data from yfinance for {yf_ticker}")
+
+    name, info, live = _get_kabutan_profile(ticker)
+    records = [
+        OHLCV(
+            date=idx.date(),
+            open=float(row["Open"]),
+            high=float(row["High"]),
+            low=float(row["Low"]),
+            close=float(row["Close"]),
+            volume=int(row["Volume"]),
+        )
+        for idx, row in df.iterrows()
+    ]
+    return StockData(
+        ticker=ticker, name=name, source="yfinance",
+        records=records, info=info, live=live,
+    )
+
+
+def _fetch_pykabutan(ticker: str, period: str, _config: Config) -> StockData:
+    import pykabutan as pk
+
+    t = pk.Ticker(ticker)
+    p = t.profile
+    info = StockInfo(
+        market=p.market or "",
+        industry=p.industry or "",
+        per=p.per,
+        pbr=p.pbr,
+        dividend_yield=p.dividend_yield,
+        market_cap=p.market_cap,
+        margin_ratio=p.margin_ratio,
+        description=p.description or "",
+    )
+    live = _parse_live_price(t._soup)  # noqa: SLF001
+    df = t.history(period=period)
+    if df.empty:
+        raise ValueError(f"No data from pykabutan for {ticker}")
+
+    df = df.sort_values("date").reset_index(drop=True)
+    records = [
+        OHLCV(
+            date=row["date"].date() if hasattr(row["date"], "date") else row["date"],
+            open=float(row["open"]),
+            high=float(row["high"]),
+            low=float(row["low"]),
+            close=float(row["close"]),
+            volume=int(row["volume"]),
+        )
+        for _, row in df.iterrows()
+    ]
+    return StockData(
+        ticker=ticker, name=p.name, source="kabutan",
+        records=records, info=info, live=live,
+    )
+
+
+def _fetch_pyjquants(ticker: str, period: str, config: Config) -> StockData:
+    import os
+
+    if not config.jquants_api_key and not os.environ.get("JQUANTS_API_KEY"):
+        raise RuntimeError("J-Quants API key not configured")
+
+    try:
+        import pyjquants as pjq
+    except ImportError:
+        raise RuntimeError("pyjquants not installed (pip install kabuchart-cli[jquants])")
+
+    t = pjq.Ticker(ticker)
+    df = t.history(period=period)
+    if df.empty:
+        raise ValueError(f"No data from pyjquants for {ticker}")
+
+    name, info, live = _get_kabutan_profile(ticker)
+    records = [
+        OHLCV(
+            date=row["date"].date() if hasattr(row["date"], "date") else row["date"],
+            open=float(row["open"]),
+            high=float(row["high"]),
+            low=float(row["low"]),
+            close=float(row["close"]),
+            volume=int(row["volume"]),
+        )
+        for _, row in df.iterrows()
+    ]
+    return StockData(
+        ticker=ticker, name=name, source="jquants",
+        records=records, info=info, live=live,
+    )
+
+
+_FETCHERS = {
+    "pyjquants": _fetch_pyjquants,
+    "yfinance": _fetch_yfinance,
+    "pykabutan": _fetch_pykabutan,
+}

kabuchart/_internal/models.py

@@ -0,0 +1,78 @@
+"""Core data models for kabuchart."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+
+
+@dataclass(frozen=True, slots=True)
+class OHLCV:
+    """Single day of stock price data."""
+
+    date: date
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: int
+
+
+@dataclass(frozen=True, slots=True)
+class StockInfo:
+    """Stock profile data from kabutan."""
+
+    market: str = ""
+    industry: str = ""
+    per: float | None = None
+    pbr: float | None = None
+    dividend_yield: float | None = None
+    market_cap: float | None = None
+    margin_ratio: float | None = None
+    description: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class LivePrice:
+    """Live/delayed price from kabutan main page."""
+
+    price: float
+    change: float
+    change_pct: float
+    time: str  # e.g. "13:25"
+
+
+@dataclass(frozen=True, slots=True)
+class StockData:
+    """Collection of OHLCV data for a ticker."""
+
+    ticker: str
+    name: str
+    source: str
+    records: list[OHLCV]
+    info: StockInfo = StockInfo()
+    live: LivePrice | None = None
+
+    @property
+    def dates(self) -> list[date]:
+        return [r.date for r in self.records]
+
+    @property
+    def opens(self) -> list[float]:
+        return [r.open for r in self.records]
+
+    @property
+    def highs(self) -> list[float]:
+        return [r.high for r in self.records]
+
+    @property
+    def lows(self) -> list[float]:
+        return [r.low for r in self.records]
+
+    @property
+    def closes(self) -> list[float]:
+        return [r.close for r in self.records]
+
+    @property
+    def volumes(self) -> list[int]:
+        return [r.volume for r in self.records]

kabuchart/cli.py

@@ -0,0 +1,44 @@
+"""CLI entry point for kabuchart."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from kabuchart._internal.chart import render
+from kabuchart._internal.data import fetch
+
+
+def _period_from_flags(days: Optional[str], months: Optional[str]) -> str:
+    """Resolve period from -d or -m flags, defaulting to 3mo."""
+    if days:
+        return days.lstrip("-")
+    if months:
+        return months.lstrip("-")
+    return "3mo"
+
+
+def main(
+    ticker: str = typer.Argument(help="Stock ticker code (e.g. 7203, 285A)"),
+    days: Optional[str] = typer.Option(
+        None, "-d", help="Date range in days (e.g. -d 30d, -d 5d)"
+    ),
+    months: Optional[str] = typer.Option(
+        None, "-m", help="Date range in months/years (e.g. -m 3mo, -m 1y)"
+    ),
+    quiet: bool = typer.Option(
+        True, "-q/ ", "--quiet/--no-quiet", help="Suppress source log line"
+    ),
+    verbose: bool = typer.Option(
+        True, "-v/ ", "--verbose/--no-verbose", help="Show stock description in header"
+    ),
+) -> None:
+    """Terminal stock charts for Japanese stocks."""
+    period = _period_from_flags(days, months)
+    data = fetch(ticker, period)
+    render(data, quiet=quiet, verbose=verbose)
+
+
+app = typer.Typer(invoke_without_command=True, no_args_is_help=True)
+app.command()(main)

kabuchart_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: kabuchart-cli
+Version: 0.1.0
+Summary: Terminal-based stock chart CLI for Japanese stocks
+Project-URL: Homepage, https://github.com/obichan117/kabuchart-cli
+Project-URL: Documentation, https://obichan117.github.io/kabuchart-cli/
+Project-URL: Repository, https://github.com/obichan117/kabuchart-cli
+Author: obichan117
+License: MIT
+Keywords: candlestick,chart,japanese,stock,terminal
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Requires-Dist: candlestick-chart>=3.1.0
+Requires-Dist: pykabutan>=0.1
+Requires-Dist: typer>=0.9
+Requires-Dist: yfinance>=0.2
+Provides-Extra: dev
+Requires-Dist: mkdocs-material>=9.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: jquants
+Requires-Dist: pyjquants>=0.1; extra == 'jquants'
+Description-Content-Type: text/markdown
+
+# kabuchart-cli
+
+Terminal-based stock chart CLI for Japanese stocks.
+
+## Install
+
+```bash
+pip install kabuchart-cli
+```
+
+## Usage
+
+```bash
+chart 285A              # candlestick chart (default: 3 months)
+chart 285A -d 30d       # last 30 days
+chart 285A -m 6mo       # last 6 months
+chart 285A -m 1y        # last 1 year
+chart 285A --no-quiet   # show data source info
+chart 285A --no-verbose # hide stock description
+```

kabuchart_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+kabuchart/__init__.py,sha256=ph5Qi0q1eZwzoBaTHo6FRF7X64Mf_0Aofh1xVH4QeW8,81
+kabuchart/cli.py,sha256=ZAK8Ubih2qBH_WSN9-cFpKXZ6IcK67VBYf45SmZLlUE,1311
+kabuchart/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kabuchart/_internal/chart.py,sha256=R52NV9_METobubVJX8R2NWhgvvHKXbmzoRcE-0_mZE8,12174
+kabuchart/_internal/config.py,sha256=GrHv3mKCvNoPfipJlg19qm5jwZFute9H-LHmYfPnlxg,1293
+kabuchart/_internal/data.py,sha256=sNnrP8De3ctwFt_H_yUFgxKVAGjjgAnBnwZk-W4LPYg,6075
+kabuchart/_internal/models.py,sha256=-EEhoy2q7s5lAvIXfFA-8Xno2GM-S_ZNpuXkjpgppnk,1688
+kabuchart_cli-0.1.0.dist-info/METADATA,sha256=gRCvN070cK4vc7IW4V9ftysgAwm0mT5TDm2mtLWtu5g,1837
+kabuchart_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+kabuchart_cli-0.1.0.dist-info/entry_points.txt,sha256=mnLxfwQDa8tFgMJZE5o4s21Ej0KH0K7X4hoZmG4qodc,44
+kabuchart_cli-0.1.0.dist-info/RECORD,,

kabuchart_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

kabuchart_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chart = kabuchart.cli:app